Gathering detailed insights and metrics for nanomatch
As of June 2024, the npm registry hosts over 2 million packages, making it one of the largest open-source software repositories in the world.
Installations
npm install nanomatchScore
57.2
Supply Chain
89.9
Quality
72.8
Maintenance
100
Vulnerability
99.6
License
Releases
Unable to fetch releases
Contributors
8
Developer
Module System
BETA
CommonJS
Statistics
96 Stars
183 Commits
20 Forks
7 Watching
5 Branches
8 Contributors
Updated on 24 Oct 2024
Languages
JavaScript (100%)
Total Downloads
Cumulative downloads
Total Downloads
4,227,265,797
Last day
8.8%
2,825,616
Compared to previous day
Last week
9.9%
15,676,088
Compared to previous week
Last month
28%
55,385,080
Compared to previous month
Last year
-21.6%
598,920,839
Compared to previous year
Daily Downloads
Weekly Downloads
Monthly Downloads
Yearly Downloads
Versions
nanomatch 
Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)
Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your :heart: and support.
Table of Contents
Details
- Install
- What is nanomatch?
- Getting started
- Documentation
- API
- Options
- options.basename
- options.bash
- options.cache
- options.dot
- options.failglob
- options.ignore
- options.matchBase
- options.nocase
- options.nodupes
- options.noglobstar
- options.nonegate
- options.nonull
- options.nullglob
- options.slash
- options.star
- options.snapdragon
- options.sourcemap
- options.unescape
- options.unixify
- Features
- Bash expansion libs
- Benchmarks
- About
Install
Install with npm:
1$ npm install --save nanomatch
Release history
History
key
Changelog entries are classified using the following labels (from keep-a-changelog):
added: for new featureschanged: for changes in existing functionalitydeprecated: for once-stable features removed in upcoming releasesremoved: for deprecated features removed in this releasefixed: for any bug fixesbumped: updated dependencies, only minor or higher will be listed.
1.1.0 - 2017-04-11
Fixed
- adds support for unclosed quotes
Added
- adds support for
options.noglobstar
1.0.4 - 2017-04-06
Housekeeping updates. Adds documentation section about escaping, cleans up utils.
1.0.3 - 2017-04-06
This release includes fixes for windows path edge cases and other improvements for stricter adherence to bash spec.
Fixed
- More windows path edge cases
Added
- Support for bash-like quoted strings for escaping sequences of characters, such as
foo/"**"/barwhere**should be matched literally and not evaluated as special characters.
1.0.1 - 2016-12-12
Added
- Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
1.0.0 - 2016-12-12
Stable release.
[0.1.0] - 2016-10-08
First release.
What is nanomatch?
Nanomatch is a fast and accurate glob matcher with full support for standard Bash glob features, including the following "metacharacters": *, **, ? and [...].
Learn more
- Getting started: learn how to install and begin using nanomatch
- Features: jump to info about supported patterns, and a glob matching reference
- API documentation: jump to available options and methods
- Unit tests: visit unit tests. there is no better way to learn a code library than spending time the unit tests. Nanomatch has 36,000 unit tests - go become a glob matching ninja!
How is this different?
Speed and accuracy
Nanomatch uses snapdragon for parsing and compiling globs, which results in:
- Granular control over the entire conversion process in a way that is easy to understand, reason about, and customize.
- Faster matching, from a combination of optimized glob patterns and (optional) caching.
- Much greater accuracy than minimatch. In fact, nanomatch passes all of the spec tests from bash, including some that bash still fails. However, since there is no real specification for globs, if you encounter a pattern that yields unexpected match results after researching previous issues, please let us know.
Basic globbing only
Nanomatch supports basic globbing only, which is limited to *, **, ? and regex-like brackets.
If you need support for the other bash "expansion" types (in addition to the wildcard matching provided by nanomatch), consider using micromatch instead. (micromatch >=3.0.0 uses the nanomatch parser and compiler for basic glob matching)
Getting started
Installing nanomatch
Install with yarn
1$ yarn add nanomatch
Install with npm
1$ npm install nanomatch
Usage
Add nanomatch to your project using node's require() system:
1var nanomatch = require('nanomatch'); 2 3// the main export is a function that takes an array of strings to match 4// and a string or array of patterns to use for matching 5nanomatch(list, patterns[, options]);
Params
list{String|Array}: List of strings to perform matches against. This is often a list of file paths.patterns{String|Array}: One or more glob paterns to use for matching.options{Object}: Any supported options may be passed
Examples
1var nm = require('nanomatch'); 2console.log(nm(['a', 'b/b', 'c/c/c'], '*')); 3//=> ['a'] 4 5console.log(nm(['a', 'b/b', 'c/c/c'], '*/*')); 6//=> ['b/b'] 7 8console.log(nm(['a', 'b/b', 'c/c/c'], '**')); 9//=> ['a', 'b/b', 'c/c/c']
See the API documentation for available methods and options.
Documentation
Escaping
Backslashes and quotes can be used to escape characters, forcing nanomatch to regard those characters as a literal characters.
Backslashes
Use backslashes to escape single characters. For example, the following pattern would match foo/*/bar exactly:
1'foo/\*/bar'
The following pattern would match foo/ followed by a literal *, followed by zero or more of any characters besides /, followed by /bar.
1'foo/\**/bar'
Quoted strings
Use single or double quotes to escape sequences of characters. For example, the following patterns would match foo/**/bar exactly:
1'foo/"**"/bar' 2'foo/\'**\'/bar' 3"foo/'**'/bar"
Matching literal quotes
If you need to match quotes literally, you can escape them as well. For example, the following will match foo/"*"/bar, foo/"a"/bar, foo/"b"/bar, or foo/"c"/bar:
1'foo/\\"*\\"/bar'
And the following will match foo/'*'/bar, foo/'a'/bar, foo/'b'/bar, or foo/'c'/bar:
1'foo/\\\'*\\\'/bar'
API
nanomatch
The main function takes a list of strings and one or more glob patterns to use for matching.
Params
list{Array}: A list of strings to matchpatterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Array}: Returns an array of matches
Example
1var nm = require('nanomatch'); 2nm(list, patterns[, options]); 3 4console.log(nm(['a.js', 'a.txt'], ['*.js'])); 5//=> [ 'a.js' ]
.match
Similar to the main function, but pattern must be a string.
Params
list{Array}: Array of strings to matchpattern{String}: Glob pattern to use for matching.options{Object}: See available options for changing how matches are performedreturns{Array}: Returns an array of matches
Example
1var nm = require('nanomatch'); 2nm.match(list, pattern[, options]); 3 4console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a')); 5//=> ['a.a', 'a.aa']
.isMatch
Returns true if the specified string matches the given glob pattern.
Params
string{String}: String to matchpattern{String}: Glob pattern to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if the string matches the glob pattern.
Example
1var nm = require('nanomatch'); 2nm.isMatch(string, pattern[, options]); 3 4console.log(nm.isMatch('a.a', '*.a')); 5//=> true 6console.log(nm.isMatch('a.b', '*.a')); 7//=> false
.some
Returns true if some of the elements in the given list match any of the given glob patterns.
Params
list{String|Array}: The string or array of strings to test. Returns as soon as the first match is found.patterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if any patterns matchstr
Example
1var nm = require('nanomatch'); 2nm.some(list, patterns[, options]); 3 4console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); 5// true 6console.log(nm.some(['foo.js'], ['*.js', '!foo.js'])); 7// false
.every
Returns true if every element in the given list matches at least one of the given glob patterns.
Params
list{String|Array}: The string or array of strings to test.patterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if any patterns matchstr
Example
1var nm = require('nanomatch'); 2nm.every(list, patterns[, options]); 3 4console.log(nm.every('foo.js', ['foo.js'])); 5// true 6console.log(nm.every(['foo.js', 'bar.js'], ['*.js'])); 7// true 8console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); 9// false 10console.log(nm.every(['foo.js'], ['*.js', '!foo.js'])); 11// false
.any
Returns true if any of the given glob patterns match the specified string.
Params
str{String|Array}: The string to test.patterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if any patterns matchstr
Example
1var nm = require('nanomatch'); 2nm.any(string, patterns[, options]); 3 4console.log(nm.any('a.a', ['b.*', '*.a'])); 5//=> true 6console.log(nm.any('a.a', 'b.*')); 7//=> false
.all
Returns true if all of the given patterns match the specified string.
Params
str{String|Array}: The string to test.patterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if any patterns matchstr
Example
1var nm = require('nanomatch'); 2nm.all(string, patterns[, options]); 3 4console.log(nm.all('foo.js', ['foo.js'])); 5// true 6 7console.log(nm.all('foo.js', ['*.js', '!foo.js'])); 8// false 9 10console.log(nm.all('foo.js', ['*.js', 'foo.js'])); 11// true 12 13console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js'])); 14// true
.not
Returns a list of strings that do not match any of the given patterns.
Params
list{Array}: Array of strings to match.patterns{String|Array}: One or more glob pattern to use for matching.options{Object}: See available options for changing how matches are performedreturns{Array}: Returns an array of strings that do not match the given patterns.
Example
1var nm = require('nanomatch'); 2nm.not(list, patterns[, options]); 3 4console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a')); 5//=> ['b.b', 'c.c']
.contains
Returns true if the given string contains the given pattern. Similar to .isMatch but the pattern can match any part of the string.
Params
str{String}: The string to match.patterns{String|Array}: Glob pattern to use for matching.options{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns true if the patter matches any part ofstr.
Example
1var nm = require('nanomatch'); 2nm.contains(string, pattern[, options]); 3 4console.log(nm.contains('aa/bb/cc', '*b')); 5//=> true 6console.log(nm.contains('aa/bb/cc', '*d')); 7//=> false
.matchKeys
Filter the keys of the given object with the given glob pattern and options. Does not attempt to match nested keys. If you need this feature, use glob-object instead.
Params
object{Object}: The object with keys to filter.patterns{String|Array}: One or more glob patterns to use for matching.options{Object}: See available options for changing how matches are performedreturns{Object}: Returns an object with only keys that match the given patterns.
Example
1var nm = require('nanomatch'); 2nm.matchKeys(object, patterns[, options]); 3 4var obj = { aa: 'a', ab: 'b', ac: 'c' }; 5console.log(nm.matchKeys(obj, '*b')); 6//=> { ab: 'b' }
.matcher
Returns a memoized matcher function from the given glob pattern and options. The returned function takes a string to match as its only argument and returns true if the string is a match.
Params
pattern{String}: Glob patternoptions{Object}: See available options for changing how matches are performed.returns{Function}: Returns a matcher function.
Example
1var nm = require('nanomatch'); 2nm.matcher(pattern[, options]); 3 4var isMatch = nm.matcher('*.!(*a)'); 5console.log(isMatch('a.a')); 6//=> false 7console.log(isMatch('a.b')); 8//=> true
.capture
Returns an array of matches captured by pattern in string, ornull` if the pattern did not match.
Params
pattern{String}: Glob pattern to use for matching.string{String}: String to matchoptions{Object}: See available options for changing how matches are performedreturns{Boolean}: Returns an array of captures if the string matches the glob pattern, otherwisenull.
Example
1var nm = require('nanomatch'); 2nm.capture(pattern, string[, options]); 3 4console.log(nm.capture('test/*.js', 'test/foo.js')); 5//=> ['foo'] 6console.log(nm.capture('test/*.js', 'foo/bar.css')); 7//=> null
.makeRe
Create a regular expression from the given glob pattern.
Params
pattern{String}: A glob pattern to convert to regex.options{Object}: See available options for changing how matches are performed.returns{RegExp}: Returns a regex created from the given pattern.
Example
1var nm = require('nanomatch'); 2nm.makeRe(pattern[, options]); 3 4console.log(nm.makeRe('*.js')); 5//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
.create
Parses the given glob pattern and returns an object with the compiled output and optional source map.
Params
pattern{String}: Glob pattern to parse and compile.options{Object}: Any options to change how parsing and compiling is performed.returns{Object}: Returns an object with the parsed AST, compiled string and optional source map.
Example
1var nm = require('nanomatch'); 2nm.create(pattern[, options]); 3 4console.log(nm.create('abc/*.js')); 5// { options: { source: 'string', sourcemap: true }, 6// state: {}, 7// compilers: 8// { ... }, 9// output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js', 10// ast: 11// { type: 'root', 12// errors: [], 13// nodes: 14// [ ... ], 15// dot: false, 16// input: 'abc/*.js' }, 17// parsingErrors: [], 18// map: 19// { version: 3, 20// sources: [ 'string' ], 21// names: [], 22// mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE', 23// sourcesContent: [ 'abc/*.js' ] }, 24// position: { line: 1, column: 28 }, 25// content: {}, 26// files: {}, 27// idx: 6 }
.parse
Parse the given str with the given options.
Params
str{String}options{Object}returns{Object}: Returns an AST
Example
1var nm = require('nanomatch'); 2nm.parse(pattern[, options]); 3 4var ast = nm.parse('a/{b,c}/d'); 5console.log(ast); 6// { type: 'root', 7// errors: [], 8// input: 'a/{b,c}/d', 9// nodes: 10// [ { type: 'bos', val: '' }, 11// { type: 'text', val: 'a/' }, 12// { type: 'brace', 13// nodes: 14// [ { type: 'brace.open', val: '{' }, 15// { type: 'text', val: 'b,c' }, 16// { type: 'brace.close', val: '}' } ] }, 17// { type: 'text', val: '/d' }, 18// { type: 'eos', val: '' } ] }
.compile
Compile the given ast or string with the given options.
Params
ast{Object|String}options{Object}returns{Object}: Returns an object that has anoutputproperty with the compiled string.
Example
1var nm = require('nanomatch'); 2nm.compile(ast[, options]); 3 4var ast = nm.parse('a/{b,c}/d'); 5console.log(nm.compile(ast)); 6// { options: { source: 'string' }, 7// state: {}, 8// compilers: 9// { eos: [Function], 10// noop: [Function], 11// bos: [Function], 12// brace: [Function], 13// 'brace.open': [Function], 14// text: [Function], 15// 'brace.close': [Function] }, 16// output: [ 'a/(b|c)/d' ], 17// ast: 18// { ... }, 19// parsingErrors: [] }
.clearCache
Clear the regex cache.
Example
1nm.clearCache();
Options
basename
options.basename
Allow glob patterns without slashes to match a file path based on its basename. Same behavior as minimatch option matchBase.
Type: boolean
Default: false
Example
1nm(['a/b.js', 'a/c.md'], '*.js'); 2//=> [] 3 4nm(['a/b.js', 'a/c.md'], '*.js', {matchBase: true}); 5//=> ['a/b.js']
bash
options.bash
Enabled by default, this option enforces bash-like behavior with stars immediately following a bracket expression. Bash bracket expressions are similar to regex character classes, but unlike regex, a star following a bracket expression does not repeat the bracketed characters. Instead, the star is treated the same as an other star.
Type: boolean
Default: true
Example
1var files = ['abc', 'ajz']; 2console.log(nm(files, '[a-c]*')); 3//=> ['abc', 'ajz'] 4 5console.log(nm(files, '[a-c]*', {bash: false}));
cache
options.cache
Disable regex and function memoization.
Type: boolean
Default: undefined
failglob
options.failglob
Similar to the --failglob behavior in Bash, throws an error when no matches are found.
Type: boolean
Default: undefined
ignore
options.ignore
String or array of glob patterns to match files to ignore.
Type: String|Array
Default: undefined
nocase
options.nocase
Use a case-insensitive regex for matching files. Same behavior as minimatch.
Type: boolean
Default: undefined
nodupes
options.nodupes
Remove duplicate elements from the result array.
Type: boolean
Default: true (enabled by default)
Example
Example of using the unescape and nodupes options together:
1nm.match(['a/b/c', 'a/b/c'], '**'); 2//=> ['abc'] 3 4nm.match(['a/b/c', 'a/b/c'], '**', {nodupes: false}); 5//=> ['a/b/c', 'a/b/c']
nonegate
options.noglobstar
Disable matching with globstars (**).
Type: boolean
Default: undefined
1nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**'); 2//=> ['a/b', 'a/b/c', 'a/b/c/d'] 3 4nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true}); 5//=> ['a/b']
nonegate
options.nonegate
Disallow negation (!) patterns, and treat leading ! as a literal character to match.
Type: boolean
Default: undefined
nullglob
options.nullglob
If true, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as minimatch option nonull.
Type: boolean
Default: undefined
slash
options.slash
Customize the slash character(s) to use for matching.
Type: string|function
Default: [/\\] (forward slash and backslash)
star
options.star
Customize the star character(s) to use for matching. It's not recommended that you modify this unless you have advanced knowledge of the compiler and matching rules.
Type: string|function
Default: [^/\\]*?
snapdragon
options.snapdragon
Pass your own instance of snapdragon to customize parsers or compilers.
Type: object
Default: undefined
snapdragon
options.sourcemap
Generate a source map by enabling the sourcemap option with the .parse, .compile, or .create methods.
Examples
1var nm = require('nanomatch'); 2 3var res = nm.create('abc/*.js', {sourcemap: true}); 4console.log(res.map); 5// { version: 3, 6// sources: [ 'string' ], 7// names: [], 8// mappings: 'AAAA,GAAG,EAAC,iBAAC,EAAC,EAAE', 9// sourcesContent: [ 'abc/*.js' ] } 10 11var ast = nm.parse('abc/**/*.js'); 12var res = nm.compile(ast, {sourcemap: true}); 13console.log(res.map); 14// { version: 3, 15// sources: [ 'string' ], 16// names: [], 17// mappings: 'AAAA,GAAG,EAAC,2BAAE,EAAC,iBAAC,EAAC,EAAE', 18// sourcesContent: [ 'abc/**/*.js' ] }
unescape
options.unescape
Remove backslashes from returned matches.
Type: boolean
Default: undefined
Example
In this example we want to match a literal *:
1nm.match(['abc', 'a\\*c'], 'a\\*c'); 2//=> ['a\\*c'] 3 4nm.match(['abc', 'a\\*c'], 'a\\*c', {unescape: true}); 5//=> ['a*c']
unixify
options.unixify
Convert path separators on returned files to posix/unix-style forward slashes.
Type: boolean
Default: true
Example
1nm.match(['a\\b\\c'], 'a/**'); 2//=> ['a/b/c'] 3 4nm.match(['a\\b\\c'], {unixify: false}); 5//=> ['a\\b\\c']
Features
Nanomatch has full support for standard Bash glob features, including the following "metacharacters": *, **, ? and [...].
Here are some examples of how they work:
| Pattern | Description |
|---|---|
* | Matches any string except for /, leading ., or /. inside a path |
** | Matches any string including /, but not a leading . or /. inside a path. More than two stars (e.g. *** is treated the same as one star, and ** loses its special meaning |
foo* | Matches any string beginning with foo |
*bar* | Matches any string containing bar (beginning, middle or end) |
*.min.js | Matches any string ending with .min.js |
[abc]*.js | Matches any string beginning with a, b, or c and ending with .js |
abc? | Matches abcd or abcz but not abcde |
The exceptions noted for * apply to all patterns that contain a *.
Not supported
The following extended-globbing features are not supported:
- brace expansion (e.g.
{a,b,c}) - extglobs (e.g.
@(a|!(c|d))) - POSIX brackets (e.g.
[[:alpha:][:digit:]])
If you need any of these features consider using micromatch instead.
Bash expansion libs
Nanomatch is part of a suite of libraries aimed at bringing the power and expressiveness of Bash's matching and expansion capabilities to JavaScript, and - as you can see by the benchmarks - without sacrificing speed.
| Related library | Matching Type | Example | Description |
|---|---|---|---|
nanomatch (you are here) | Wildcards | * | Filename expansion, also referred to as globbing and pathname expansion, allows the use of wildcards for matching. |
| expand-tilde | Tildes | ~ | Tilde expansion converts the leading tilde in a file path to the user home directory. |
| braces | Braces | {a,b,c} | Brace expansion |
| expand-brackets | Brackets | [[:alpha:]] | POSIX character classes (also referred to as POSIX brackets, or POSIX character classes) |
| extglob | Parens | `!(a\ | b)` |
| micromatch | All | all | Micromatch is built on top of the other libraries. |
There are many resources available on the web if you want to dive deeper into how these features work in Bash.
Benchmarks
Running benchmarks
Install dev dependencies:
1npm i -d && node benchmark
Nanomatch vs. Minimatch vs. Multimatch
1# globstar-basic (182 bytes) 2 minimatch x 69,512 ops/sec ±1.92% (88 runs sampled) 3 multimatch x 63,376 ops/sec ±1.41% (89 runs sampled) 4 nanomatch x 432,451 ops/sec ±0.92% (88 runs sampled) 5 6 fastest is nanomatch (by 651% avg) 7 8# large-list-globstar (485686 bytes) 9 minimatch x 34.02 ops/sec ±1.42% (59 runs sampled) 10 multimatch x 33.58 ops/sec ±1.97% (58 runs sampled) 11 nanomatch x 483 ops/sec ±1.06% (86 runs sampled) 12 13 fastest is nanomatch (by 1429% avg) 14 15# long-list-globstar (194085 bytes) 16 minimatch x 383 ops/sec ±0.74% (90 runs sampled) 17 multimatch x 378 ops/sec ±0.59% (89 runs sampled) 18 nanomatch x 990 ops/sec ±1.14% (85 runs sampled) 19 20 fastest is nanomatch (by 260% avg) 21 22# negation-basic (132 bytes) 23 minimatch x 242,145 ops/sec ±1.17% (89 runs sampled) 24 multimatch x 76,403 ops/sec ±0.78% (92 runs sampled) 25 nanomatch x 537,253 ops/sec ±1.44% (86 runs sampled) 26 27 fastest is nanomatch (by 337% avg) 28 29# not-glob-basic (93 bytes) 30 minimatch x 252,402 ops/sec ±1.33% (89 runs sampled) 31 multimatch x 209,954 ops/sec ±1.30% (90 runs sampled) 32 nanomatch x 1,716,468 ops/sec ±1.13% (86 runs sampled) 33 34 fastest is nanomatch (by 742% avg) 35 36# star-basic (93 bytes) 37 minimatch x 182,780 ops/sec ±1.41% (91 runs sampled) 38 multimatch x 153,210 ops/sec ±0.72% (89 runs sampled) 39 nanomatch x 599,621 ops/sec ±1.22% (90 runs sampled) 40 41 fastest is nanomatch (by 357% avg) 42
About
Contributing
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 Tests
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:
1$ npm install && npm test
Building docs
(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:
1$ npm install -g verbose/verb#dev verb-generate-readme && verb
Related projects
You might also be interested in these projects:
- extglob: Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… more | homepage
- is-extglob: Returns true if a string has an extglob. | homepage
- is-glob: Returns
trueif the given string looks like a glob pattern or an extglob pattern… more | homepage - micromatch: Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | homepage
Contributors
| Commits | Contributor |
|---|---|
| 164 | jonschlinkert |
| 1 | devongovett |
Author
Jon Schlinkert
License
Copyright © 2018, Jon Schlinkert. Released under the MIT License.
This file was generated by verb-generate-readme, v0.6.0, on February 18, 2018.
No vulnerabilities found.
Reason
license file detected
Details
- Info: project has a license file: LICENSE:0
- Info: FSF or OSI recognized license: MIT License: LICENSE:0
Reason
no binaries found in the repo
Reason
0 existing vulnerabilities detected
Reason
security policy file detected
Details
- Info: security policy file detected: github.com/micromatch/.github/SECURITY.md:1
- Info: Found linked content: github.com/micromatch/.github/SECURITY.md:1
- Info: Found disclosure, vulnerability, and/or timelines in security policy: github.com/micromatch/.github/SECURITY.md:1
- Info: Found text in security policy: github.com/micromatch/.github/SECURITY.md:1
Reason
Found 2/24 approved changesets -- score normalized to 0
Reason
0 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 0
Reason
no effort to earn an OpenSSF best practices badge detected
Reason
branch protection not enabled on development/release branches
Details
- Warn: branch protection not enabled for branch 'master'
Reason
project is not fuzzed
Details
- Warn: no fuzzer integrations found
Reason
SAST tool is not run on all commits -- score normalized to 0
Details
- Warn: 0 commits out of 9 are checked with a SAST tool
Score
3.9
/10
Last Scanned on 2024-11-11
The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.
Learn More