Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.
The picomatch npm package is a minimal matching utility that uses glob patterns to test, match, or parse strings. It is designed to be a faster and lighter alternative to other pattern matching libraries, with a focus on performance and accuracy.
Glob matching
Use picomatch to create a matcher function for glob patterns, which can then be used to test if strings match the pattern.
const picomatch = require('picomatch');
const isMatch = picomatch('*.js');
console.log(isMatch('file.js')); // true
console.log(isMatch('file.txt')); // falseMultiple patterns
Create a matcher function that can handle multiple patterns, including negation patterns, to match against strings.
const picomatch = require('picomatch');
const isMatch = picomatch(['*.js', '!foo.js']);
console.log(isMatch('file.js')); // true
console.log(isMatch('foo.js')); // falseParse glob patterns
Parse glob patterns to analyze their structure and components, which can be useful for understanding the pattern or for further processing.
const picomatch = require('picomatch');
const result = picomatch.parse('*.js');
console.log(result);Minimatch is a glob processing library that provides similar functionality to picomatch. It is widely used but is generally slower and less minimal than picomatch.
Micromatch is a more extensive glob matching library built on top of picomatch. It offers additional features and capabilities but is larger in size.
Fast-glob is a fast and efficient library for matching against file paths. It is optimized for file system operations and can handle a large number of patterns and files.
Node-glob is a glob implementation for Node.js that provides pattern matching and directory traversal. It is feature-rich but not as performant as picomatch for simple pattern matching tasks.
Blazing fast and accurate glob matcher written in JavaScript.
No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.
* and ?), globstars (**) for nested directories, advanced globbing with extglobs, braces, and POSIX brackets, and support for escaping special characters with \ or quotes.See the library comparison to other libraries.
(TOC generated by verb using markdown-toc)
Install with npm:
npm install --save picomatch
The main export is a function that takes a glob pattern and an options object and returns a function for matching strings.
const pm = require('picomatch');
const isMatch = pm('*.js');
console.log(isMatch('abcd')); //=> false
console.log(isMatch('a.js')); //=> true
console.log(isMatch('a.md')); //=> false
console.log(isMatch('a/b.js')); //=> false
Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information.
Params
globs {String|Array}: One or more glob patterns.options {Object=}returns {Function=}: Returns a matcher function.Example
const picomatch = require('picomatch');
// picomatch(glob[, options]);
const isMatch = picomatch('*.!(*a)');
console.log(isMatch('a.a')); //=> false
console.log(isMatch('a.b')); //=> true
Example without node.js
For environments without node.js, picomatch/posix provides you a dependency-free matcher, without automatic OS detection.
const picomatch = require('picomatch/posix');
// the same API, defaulting to posix paths
const isMatch = picomatch('a/*');
console.log(isMatch('a\\b')); //=> false
console.log(isMatch('a/b')); //=> true
// you can still configure the matcher function to accept windows paths
const isMatch = picomatch('a/*', { options: windows });
console.log(isMatch('a\\b')); //=> true
console.log(isMatch('a/b')); //=> true
Test input with the given regex. This is used by the main picomatch() function to test the input string.
Params
input {String}: String to test.regex {RegExp}returns {Object}: Returns an object with matching info.Example
const picomatch = require('picomatch');
// picomatch.test(input, regex[, options]);
console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
Match the basename of a filepath.
Params
input {String}: String to test.glob {RegExp|String}: Glob pattern or regex created by .makeRe.returns {Boolean}Example
const picomatch = require('picomatch');
// picomatch.matchBase(input, glob[, options]);
console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
Returns true if any of the given glob patterns match the specified string.
Params
returns {Boolean}: Returns true if any patterns match strExample
const picomatch = require('picomatch');
// picomatch.isMatch(string, patterns[, options]);
console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
Parse a glob pattern to create the source string for a regular expression.
Params
pattern {String}options {Object}returns {Object}: Returns an object with useful properties and output to be used as a regex source string.Example
const picomatch = require('picomatch');
const result = picomatch.parse(pattern[, options]);
Scan a glob pattern to separate the pattern into segments.
Params
input {String}: Glob pattern to scan.options {Object}returns {Object}: Returns an object withExample
const picomatch = require('picomatch');
// picomatch.scan(input[, options]);
const result = picomatch.scan('!./foo/*.js');
console.log(result);
{ prefix: '!./',
input: '!./foo/*.js',
start: 3,
base: 'foo',
glob: '*.js',
isBrace: false,
isBracket: false,
isGlob: true,
isExtglob: false,
isGlobstar: false,
negated: true }
Compile a regular expression from the state object returned by the
parse() method.
Params
state {Object}options {Object}returnOutput {Boolean}: Intended for implementors, this argument allows you to return the raw output from the parser.returnState {Boolean}: Adds the state to a state property on the returned regex. Useful for implementors and debugging.returns {RegExp}Create a regular expression from a parsed glob pattern.
Params
state {String}: The object returned from the .parse method.options {Object}returnOutput {Boolean}: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.returnState {Boolean}: Implementors may use this argument to return the state from the parsed glob with the returned regular expression.returns {RegExp}: Returns a regex created from the given pattern.Example
const picomatch = require('picomatch');
const state = picomatch.parse('*.js');
// picomatch.compileRe(state[, options]);
console.log(picomatch.compileRe(state));
//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
Create a regular expression from the given regex source string.
Params
source {String}: Regular expression source string.options {Object}returns {RegExp}Example
const picomatch = require('picomatch');
// picomatch.toRegex(source[, options]);
const { output } = picomatch.parse('*.js');
console.log(picomatch.toRegex(output));
//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
The following options may be used with the main picomatch() function or any of the methods on the picomatch API.
| Option | Type | Default value | Description |
|---|---|---|---|
basename | boolean | false | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, a?b would match the path /xyz/123/acb, but not /xyz/acb/123. |
bash | boolean | false | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (**). |
capture | boolean | undefined | Return regex matches in supporting methods. |
contains | boolean | undefined | Allows glob to match any part of the given string(s). |
cwd | string | process.cwd() | Current working directory. Used by picomatch.split() |
debug | boolean | undefined | Debug regular expressions when an error is thrown. |
dot | boolean | false | Enable dotfile matching. By default, dotfiles are ignored unless a . is explicitly defined in the pattern, or options.dot is true |
expandRange | function | undefined | Custom function for expanding ranges in brace patterns, such as {a..z}. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. |
failglob | boolean | false | Throws an error if no matches are found. Based on the bash option of the same name. |
fastpaths | boolean | true | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to false. |
flags | string | undefined | Regex flags to use in the generated regex. If defined, the nocase option will be overridden. |
| format | function | undefined | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
ignore | array|string | undefined | One or more glob patterns for excluding strings that should not be matched from the result. |
keepQuotes | boolean | false | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. |
literalBrackets | boolean | undefined | When true, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
matchBase | boolean | false | Alias for basename |
maxLength | boolean | 65536 | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
nobrace | boolean | false | Disable brace matching, so that {a,b} and {1..3} would be treated as literal characters. |
nobracket | boolean | undefined | Disable matching with regex brackets. |
nocase | boolean | false | Make matching case-insensitive. Equivalent to the regex i flag. Note that this option is overridden by the flags option. |
nodupes | boolean | true | Deprecated, use nounique instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. |
noext | boolean | false | Alias for noextglob |
noextglob | boolean | false | Disable support for matching with extglobs (like +(a|b)) |
noglobstar | boolean | false | Disable support for matching nested directories with globstars (**) |
nonegate | boolean | false | Disable support for negating with leading ! |
noquantifiers | boolean | false | Disable support for regex quantifiers (like a{1,2}) and treat them as brace patterns to be expanded. |
| onIgnore | function | undefined | Function to be called on ignored items. |
| onMatch | function | undefined | Function to be called on matched items. |
| onResult | function | undefined | Function to be called on all items, regardless of whether or not they are matched or ignored. |
posix | boolean | false | Support POSIX character classes ("posix brackets"). |
posixSlashes | boolean | undefined | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself |
prepend | boolean | undefined | String to prepend to the generated regex used for matching. |
regex | boolean | false | Use regular expression rules for + (instead of matching literal +), and for stars that follow closing parentheses or brackets (as in )* and ]*). |
strictBrackets | boolean | undefined | Throw an error if brackets, braces, or parens are imbalanced. |
strictSlashes | boolean | undefined | When true, picomatch won't match trailing slashes with single stars. |
unescape | boolean | undefined | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. |
unixify | boolean | undefined | Alias for posixSlashes, for backwards compatibility. |
windows | boolean | false | Also accept backslashes as the path separator. |
In addition to the main picomatch options, the following options may also be used with the .scan method.
| Option | Type | Default value | Description |
|---|---|---|---|
tokens | boolean | false | When true, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern |
parts | boolean | false | When true, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when options.tokens is true |
Example
const picomatch = require('picomatch');
const result = picomatch.scan('!./foo/*.js', { tokens: true });
console.log(result);
// {
// prefix: '!./',
// input: '!./foo/*.js',
// start: 3,
// base: 'foo',
// glob: '*.js',
// isBrace: false,
// isBracket: false,
// isGlob: true,
// isExtglob: false,
// isGlobstar: false,
// negated: true,
// maxDepth: 2,
// tokens: [
// { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true },
// { value: 'foo', depth: 1, isGlob: false },
// { value: '*.js', depth: 1, isGlob: true }
// ],
// slashes: [ 2, 6 ],
// parts: [ 'foo', '*.js' ]
// }
Type: function
Default: undefined
Custom function for expanding ranges in brace patterns. The fill-range library is ideal for this purpose, or you can use custom code to do whatever you need.
Example
The following example shows how to create a glob that matches a folder
const fill = require('fill-range');
const regex = pm.makeRe('foo/{01..25}/bar', {
expandRange(a, b) {
return `(${fill(a, b, { toRegex: true })})`;
}
});
console.log(regex);
//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
console.log(regex.test('foo/00/bar')) // false
console.log(regex.test('foo/01/bar')) // true
console.log(regex.test('foo/10/bar')) // true
console.log(regex.test('foo/22/bar')) // true
console.log(regex.test('foo/25/bar')) // true
console.log(regex.test('foo/26/bar')) // false
Type: function
Default: undefined
Custom function for formatting strings before they're matched.
Example
// strip leading './' from strings
const format = str => str.replace(/^\.\//, '');
const isMatch = picomatch('foo/*.js', { format });
console.log(isMatch('./foo/bar.js')); //=> true
const onMatch = ({ glob, regex, input, output }) => {
console.log({ glob, regex, input, output });
};
const isMatch = picomatch('*', { onMatch });
isMatch('foo');
isMatch('bar');
isMatch('baz');
const onIgnore = ({ glob, regex, input, output }) => {
console.log({ glob, regex, input, output });
};
const isMatch = picomatch('*', { onIgnore, ignore: 'f*' });
isMatch('foo');
isMatch('bar');
isMatch('baz');
const onResult = ({ glob, regex, input, output }) => {
console.log({ glob, regex, input, output });
};
const isMatch = picomatch('*', { onResult, ignore: 'f*' });
isMatch('foo');
isMatch('bar');
isMatch('baz');
| Character | Description |
|---|---|
* | Matches any character zero or more times, excluding path separators. Does not match path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the dot option to true. |
** | Matches any character zero or more times, including path separators. Note that ** will only match path separators (/, and \\ with the windows option) when they are the only characters in a path segment. Thus, foo**/bar is equivalent to foo*/bar, and foo/a**b/bar is equivalent to foo/a*b/bar, and more than two consecutive stars in a glob path segment are regarded as a single star. Thus, foo/***/bar is equivalent to foo/*/bar. |
? | Matches any character excluding path separators one time. Does not match path separators or leading dots. |
[abc] | Matches any characters inside the brackets. For example, [abc] would match the characters a, b or c, and nothing else. |
Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions:
foo/bar/baz with *. Picomatch only matches nested directories with **.!(foo)* should match foo and foobar, since the trailing * bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return false for both foo and foobar.| Pattern | Description |
|---|---|
@(pattern) | Match only one consecutive occurrence of pattern |
*(pattern) | Match zero or more consecutive occurrences of pattern |
+(pattern) | Match one or more consecutive occurrences of pattern |
?(pattern) | Match zero or one consecutive occurrences of pattern |
!(pattern) | Match anything but pattern |
Examples
const pm = require('picomatch');
// *(pattern) matches ZERO or more of "pattern"
console.log(pm.isMatch('a', 'a*(z)')); // true
console.log(pm.isMatch('az', 'a*(z)')); // true
console.log(pm.isMatch('azzz', 'a*(z)')); // true
// +(pattern) matches ONE or more of "pattern"
console.log(pm.isMatch('a', 'a+(z)')); // false
console.log(pm.isMatch('az', 'a+(z)')); // true
console.log(pm.isMatch('azzz', 'a+(z)')); // true
// supports multiple extglobs
console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false
// supports nested extglobs
console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true
POSIX classes are disabled by default. Enable this feature by setting the posix option to true.
Enable POSIX bracket support
console.log(pm.makeRe('[[:word:]]+', { posix: true }));
//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/
Supported POSIX classes
The following named POSIX bracket expressions are supported:
[:alnum:] - Alphanumeric characters, equ [a-zA-Z0-9][:alpha:] - Alphabetical characters, equivalent to [a-zA-Z].[:ascii:] - ASCII characters, equivalent to [\\x00-\\x7F].[:blank:] - Space and tab characters, equivalent to [ \\t].[:cntrl:] - Control characters, equivalent to [\\x00-\\x1F\\x7F].[:digit:] - Numerical digits, equivalent to [0-9].[:graph:] - Graph characters, equivalent to [\\x21-\\x7E].[:lower:] - Lowercase letters, equivalent to [a-z].[:print:] - Print characters, equivalent to [\\x20-\\x7E ].[:punct:] - Punctuation and symbols, equivalent to [\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_{|}~]`.[:space:] - Extended space characters, equivalent to [ \\t\\r\\n\\v\\f].[:upper:] - Uppercase letters, equivalent to [A-Z].[:word:] - Word characters (letters, numbers and underscores), equivalent to [A-Za-z0-9_].[:xdigit:] - Hexadecimal digits, equivalent to [A-Fa-f0-9].See the Bash Reference Manual for more information.
Picomatch does not do brace expansion. For brace expansion and advanced matching with braces, use micromatch instead. Picomatch has very basic support for braces.
If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes:
Special Characters
Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms.
To match any of the following characters as literals: `$^*+?()[]
Examples:
console.log(pm.makeRe('foo/bar \\(1\\)'));
console.log(pm.makeRe('foo/bar \\(1\\)'));
The following table shows which features are supported by minimatch, micromatch, picomatch, nanomatch, extglob, braces, and expand-brackets.
| Feature | minimatch | micromatch | picomatch | nanomatch | extglob | braces | expand-brackets |
|---|---|---|---|---|---|---|---|
Wildcard matching (*?+) | ✔ | ✔ | ✔ | ✔ | - | - | - |
| Advancing globbing | ✔ | ✔ | ✔ | - | - | - | - |
| Brace matching | ✔ | ✔ | ✔ | - | - | ✔ | - |
| Brace expansion | ✔ | ✔ | - | - | - | ✔ | - |
| Extglobs | partial | ✔ | ✔ | - | ✔ | - | - |
| Posix brackets | - | ✔ | ✔ | - | - | - | ✔ |
| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ |
| File system operations | - | - | - | - | - | - | - |
Performance comparison of picomatch and minimatch.
(Pay special attention to the last three benchmarks. Minimatch freezes on long ranges.)
# .makeRe star (*)
picomatch x 4,449,159 ops/sec ±0.24% (97 runs sampled)
minimatch x 632,772 ops/sec ±0.14% (98 runs sampled)
# .makeRe star; dot=true (*)
picomatch x 3,500,079 ops/sec ±0.26% (99 runs sampled)
minimatch x 564,916 ops/sec ±0.23% (96 runs sampled)
# .makeRe globstar (**)
picomatch x 3,261,000 ops/sec ±0.27% (98 runs sampled)
minimatch x 1,664,766 ops/sec ±0.20% (100 runs sampled)
# .makeRe globstars (**/**/**)
picomatch x 3,284,469 ops/sec ±0.18% (97 runs sampled)
minimatch x 1,435,880 ops/sec ±0.34% (95 runs sampled)
# .makeRe with leading star (*.txt)
picomatch x 3,100,197 ops/sec ±0.35% (99 runs sampled)
minimatch x 428,347 ops/sec ±0.42% (94 runs sampled)
# .makeRe - basic braces ({a,b,c}*.txt)
picomatch x 443,578 ops/sec ±1.33% (89 runs sampled)
minimatch x 107,143 ops/sec ±0.35% (94 runs sampled)
# .makeRe - short ranges ({a..z}*.txt)
picomatch x 415,484 ops/sec ±0.76% (96 runs sampled)
minimatch x 14,299 ops/sec ±0.26% (96 runs sampled)
# .makeRe - medium ranges ({1..100000}*.txt)
picomatch x 395,020 ops/sec ±0.87% (89 runs sampled)
minimatch x 2 ops/sec ±4.59% (10 runs sampled)
# .makeRe - long ranges ({1..10000000}*.txt)
picomatch x 400,036 ops/sec ±0.83% (90 runs sampled)
minimatch (FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory)
The goal of this library is to be blazing fast, without compromising on accuracy.
Accuracy
The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: !(**/{a,b,*/c}).
Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements.
Performance
Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer.
Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.
Please read the contributing guide for advice on opening issues, pull requests, and coding standards.
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
npm install && npm test
(This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)
To generate the readme, run the following command:
npm install -g verbose/verb#dev verb-generate-readme && verb
Jon Schlinkert
Copyright © 2017-present, Jon Schlinkert. Released under the MIT License.
FAQs
Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.
We found that picomatch demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 4 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.
Security News
RubyGems.org has added a new "maintainer" role that allows for publishing new versions of gems. This new permission type is aimed at improving security for gem owners and the service overall.