‚̧Nutella Pancake Machine
    Wondering what‚Äôs next for npm?Check out our public roadmap! ¬Ľ

    nanomatch

    1.2.13¬†‚Äʬ†Public¬†‚Äʬ†Published

    nanomatch NPM version NPM monthly downloads NPM total downloads Linux Build Status Windows Build Status

    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 ‚̧ԳŹ and support.

    Table of Contents

    Details

    Install

    Install with npm:

    $ npm install --save nanomatch
    Release history

    History

    key

    Changelog entries are classified using the following labels (from keep-a-changelog):

    • added: for new features
    • changed: for changes in existing functionality
    • deprecated: for once-stable features removed in upcoming releases
    • removed: for deprecated features removed in this release
    • fixed: for any bug fixes
    • bumped: 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/"**"/bar where ** 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

    $ yarn add nanomatch

    Install with npm

    $ npm install nanomatch

    Usage

    Add nanomatch to your project using node's require() system:

    var nanomatch = require('nanomatch');
     
    // the main export is a function that takes an array of strings to match
    // and a string or array of patterns to use for matching
    nanomatch(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

    var nm = require('nanomatch');
    console.log(nm(['a', 'b/b', 'c/c/c'], '*'));
    //=> ['a']
     
    console.log(nm(['a', 'b/b', 'c/c/c'], '*/*'));
    //=> ['b/b']
     
    console.log(nm(['a', 'b/b', 'c/c/c'], '**'));
    //=> ['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:

    'foo/\*/bar'

    The following pattern would match foo/ followed by a literal *, followed by zero or more of any characters besides /, followed by /bar.

    'foo/\**/bar'

    Quoted strings

    Use single or double quotes to escape sequences of characters. For example, the following patterns would match foo/**/bar exactly:

    'foo/"**"/bar'
    'foo/\'**\'/bar'
    "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:

    'foo/\\"*\\"/bar'

    And the following will match foo/'*'/bar, foo/'a'/bar, foo/'b'/bar, or foo/'c'/bar:

    '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 match
    • patterns {String|Array}: One or more glob patterns to use for matching.
    • options {Object}: See available options for changing how matches are performed
    • returns {Array}: Returns an array of matches

    Example

    var nm = require('nanomatch');
    nm(list, patterns[, options]);
     
    console.log(nm(['a.js', 'a.txt'], ['*.js']));
    //=> [ 'a.js' ]

    .match

    Similar to the main function, but pattern must be a string.

    Params

    • list {Array}: Array of strings to match
    • pattern {String}: Glob pattern to use for matching.
    • options {Object}: See available options for changing how matches are performed
    • returns {Array}: Returns an array of matches

    Example

    var nm = require('nanomatch');
    nm.match(list, pattern[, options]);
     
    console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
    //=> ['a.a', 'a.aa']

    .isMatch

    Returns true if the specified string matches the given glob pattern.

    Params

    • string {String}: String to match
    • pattern {String}: Glob pattern to use for matching.
    • options {Object}: See available options for changing how matches are performed
    • returns {Boolean}: Returns true if the string matches the glob pattern.

    Example

    var nm = require('nanomatch');
    nm.isMatch(string, pattern[, options]);
     
    console.log(nm.isMatch('a.a', '*.a'));
    //=> true
    console.log(nm.isMatch('a.b', '*.a'));
    //=> 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 performed
    • returns {Boolean}: Returns true if any patterns match str

    Example

    var nm = require('nanomatch');
    nm.some(list, patterns[, options]);
     
    console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
    // true
    console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
    // 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 performed
    • returns {Boolean}: Returns true if any patterns match str

    Example

    var nm = require('nanomatch');
    nm.every(list, patterns[, options]);
     
    console.log(nm.every('foo.js', ['foo.js']));
    // true
    console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
    // true
    console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
    // false
    console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
    // 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 performed
    • returns {Boolean}: Returns true if any patterns match str

    Example

    var nm = require('nanomatch');
    nm.any(string, patterns[, options]);
     
    console.log(nm.any('a.a', ['b.*', '*.a']));
    //=> true
    console.log(nm.any('a.a', 'b.*'));
    //=> 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 performed
    • returns {Boolean}: Returns true if any patterns match str

    Example

    var nm = require('nanomatch');
    nm.all(string, patterns[, options]);
     
    console.log(nm.all('foo.js', ['foo.js']));
    // true
     
    console.log(nm.all('foo.js', ['*.js', '!foo.js']));
    // false
     
    console.log(nm.all('foo.js', ['*.js', 'foo.js']));
    // true
     
    console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
    // 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 performed
    • returns {Array}: Returns an array of strings that do not match the given patterns.

    Example

    var nm = require('nanomatch');
    nm.not(list, patterns[, options]);
     
    console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
    //=> ['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 performed
    • returns {Boolean}: Returns true if the patter matches any part of str.

    Example

    var nm = require('nanomatch');
    nm.contains(string, pattern[, options]);
     
    console.log(nm.contains('aa/bb/cc', '*b'));
    //=> true
    console.log(nm.contains('aa/bb/cc', '*d'));
    //=> 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 performed
    • returns {Object}: Returns an object with only keys that match the given patterns.

    Example

    var nm = require('nanomatch');
    nm.matchKeys(object, patterns[, options]);
     
    var obj = { aa: 'a', ab: 'b', ac: 'c' };
    console.log(nm.matchKeys(obj, '*b'));
    //=> { 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 pattern
    • options {Object}: See available options for changing how matches are performed.
    • returns {Function}: Returns a matcher function.

    Example

    var nm = require('nanomatch');
    nm.matcher(pattern[, options]);
     
    var isMatch = nm.matcher('*.!(*a)');
    console.log(isMatch('a.a'));
    //=> false
    console.log(isMatch('a.b'));
    //=> 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 match
    • options {Object}: See available options for changing how matches are performed
    • returns {Boolean}: Returns an array of captures if the string matches the glob pattern, otherwise null.

    Example

    var nm = require('nanomatch');
    nm.capture(pattern, string[, options]);
     
    console.log(nm.capture('test/*.js', 'test/foo.js'));
    //=> ['foo']
    console.log(nm.capture('test/*.js', 'foo/bar.css'));
    //=> 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

    var nm = require('nanomatch');
    nm.makeRe(pattern[, options]);
     
    console.log(nm.makeRe('*.js'));
    //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.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

    var nm = require('nanomatch');
    nm.create(pattern[, options]);
     
    console.log(nm.create('abc/*.js'));
    // { options: { source: 'string', sourcemap: true },
    //   state: {},
    //   compilers:
    //    { ... },
    //   output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
    //   ast:
    //    { type: 'root',
    //      errors: [],
    //      nodes:
    //       [ ... ],
    //      dot: false,
    //      input: 'abc/*.js' },
    //   parsingErrors: [],
    //   map:
    //    { version: 3,
    //      sources: [ 'string' ],
    //      names: [],
    //      mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
    //      sourcesContent: [ 'abc/*.js' ] },
    //   position: { line: 1, column: 28 },
    //   content: {},
    //   files: {},
    //   idx: 6 }

    .parse

    Parse the given str with the given options.

    Params

    • str {String}
    • options {Object}
    • returns {Object}: Returns an AST

    Example

    var nm = require('nanomatch');
    nm.parse(pattern[, options]);
     
    var ast = nm.parse('a/{b,c}/d');
    console.log(ast);
    // { type: 'root',
    //   errors: [],
    //   input: 'a/{b,c}/d',
    //   nodes:
    //    [ { type: 'bos', val: '' },
    //      { type: 'text', val: 'a/' },
    //      { type: 'brace',
    //        nodes:
    //         [ { type: 'brace.open', val: '{' },
    //           { type: 'text', val: 'b,c' },
    //           { type: 'brace.close', val: '}' } ] },
    //      { type: 'text', val: '/d' },
    //      { 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 an output property with the compiled string.

    Example

    var nm = require('nanomatch');
    nm.compile(ast[, options]);
     
    var ast = nm.parse('a/{b,c}/d');
    console.log(nm.compile(ast));
    // { options: { source: 'string' },
    //   state: {},
    //   compilers:
    //    { eos: [Function],
    //      noop: [Function],
    //      bos: [Function],
    //      brace: [Function],
    //      'brace.open': [Function],
    //      text: [Function],
    //      'brace.close': [Function] },
    //   output: [ 'a/(b|c)/d' ],
    //   ast:
    //    { ... },
    //   parsingErrors: [] }

    .clearCache

    Clear the regex cache.

    Example

    nm.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

    nm(['a/b.js', 'a/c.md'], '*.js');
    //=> []
     
    nm(['a/b.js', 'a/c.md'], '*.js', {matchBase: true});
    //=> ['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

    var files = ['abc', 'ajz'];
    console.log(nm(files, '[a-c]*'));
    //=> ['abc', 'ajz']
     
    console.log(nm(files, '[a-c]*', {bash: false}));
    cache

    options.cache

    Disable regex and function memoization.

    Type: boolean

    Default: undefined

    dot

    options.dot

    Match dotfiles. Same behavior as minimatch option dot.

    Type: boolean

    Default: false

    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

    matchBase

    options.matchBase

    Alias for options.basename.

    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:

    nm.match(['a/b/c', 'a/b/c'], '**');
    //=> ['abc']
     
    nm.match(['a/b/c', 'a/b/c'], '**', {nodupes: false});
    //=> ['a/b/c', 'a/b/c']
    nonegate

    options.noglobstar

    Disable matching with globstars (**).

    Type: boolean

    Default: undefined

    nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**');
    //=> ['a/b', 'a/b/c', 'a/b/c/d']
     
    nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true});
    //=> ['a/b']
    nonegate

    options.nonegate

    Disallow negation (!) patterns, and treat leading ! as a literal character to match.

    Type: boolean

    Default: undefined

    nonull

    options.nonull

    Alias for options.nullglob.

    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

    var nm = require('nanomatch');
     
    var res = nm.create('abc/*.js', {sourcemap: true});
    console.log(res.map);
    // { version: 3,
    //   sources: [ 'string' ],
    //   names: [],
    //   mappings: 'AAAA,GAAG,EAAC,iBAAC,EAAC,EAAE',
    //   sourcesContent: [ 'abc/*.js' ] }
     
    var ast = nm.parse('abc/**/*.js');
    var res = nm.compile(ast, {sourcemap: true});
    console.log(res.map);
    // { version: 3,
    //   sources: [ 'string' ],
    //   names: [],
    //   mappings: 'AAAA,GAAG,EAAC,2BAAE,EAAC,iBAAC,EAAC,EAAE',
    //   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 *:

    nm.match(['abc', 'a\\*c'], 'a\\*c');
    //=> ['a\\*c']
     
    nm.match(['abc', 'a\\*c'], 'a\\*c', {unescape: true});
    //=> ['a*c']
    unixify

    options.unixify

    Convert path separators on returned files to posix/unix-style forward slashes.

    Type: boolean

    Default: true

    Example

    nm.match(['a\\b\\c'], 'a/**');
    //=> ['a/b/c']
     
    nm.match(['a\\b\\c'], {unixify: false});
    //=> ['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:

    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) Extglobs
    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:

    npm i -d && node benchmark

    Nanomatch vs. Minimatch vs. Multimatch

    # globstar-basic (182 bytes) 
    ¬†¬†minimatch¬†x¬†69,512¬†ops/sec¬†¬Ī1.92%¬†(88¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†63,376¬†ops/sec¬†¬Ī1.41%¬†(89¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†432,451¬†ops/sec¬†¬Ī0.92%¬†(88¬†runs¬†sampled)
     
      fastest is nanomatch (by 651% avg)
     
    # large-list-globstar (485686 bytes) 
    ¬†¬†minimatch¬†x¬†34.02¬†ops/sec¬†¬Ī1.42%¬†(59¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†33.58¬†ops/sec¬†¬Ī1.97%¬†(58¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†483¬†ops/sec¬†¬Ī1.06%¬†(86¬†runs¬†sampled)
     
      fastest is nanomatch (by 1429% avg)
     
    # long-list-globstar (194085 bytes) 
    ¬†¬†minimatch¬†x¬†383¬†ops/sec¬†¬Ī0.74%¬†(90¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†378¬†ops/sec¬†¬Ī0.59%¬†(89¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†990¬†ops/sec¬†¬Ī1.14%¬†(85¬†runs¬†sampled)
     
      fastest is nanomatch (by 260% avg)
     
    # negation-basic (132 bytes) 
    ¬†¬†minimatch¬†x¬†242,145¬†ops/sec¬†¬Ī1.17%¬†(89¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†76,403¬†ops/sec¬†¬Ī0.78%¬†(92¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†537,253¬†ops/sec¬†¬Ī1.44%¬†(86¬†runs¬†sampled)
     
      fastest is nanomatch (by 337% avg)
     
    # not-glob-basic (93 bytes) 
    ¬†¬†minimatch¬†x¬†252,402¬†ops/sec¬†¬Ī1.33%¬†(89¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†209,954¬†ops/sec¬†¬Ī1.30%¬†(90¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†1,716,468¬†ops/sec¬†¬Ī1.13%¬†(86¬†runs¬†sampled)
     
      fastest is nanomatch (by 742% avg)
     
    # star-basic (93 bytes) 
    ¬†¬†minimatch¬†x¬†182,780¬†ops/sec¬†¬Ī1.41%¬†(91¬†runs¬†sampled)
    ¬†¬†multimatch¬†x¬†153,210¬†ops/sec¬†¬Ī0.72%¬†(89¬†runs¬†sampled)
    ¬†¬†nanomatch¬†x¬†599,621¬†ops/sec¬†¬Ī1.22%¬†(90¬†runs¬†sampled)
     
      fastest is nanomatch (by 357% avg)
     

    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:

    $ 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:

    $ 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 true if 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.

    Install

    npm i nanomatch

    DownloadsWeekly Downloads

    16,134,622

    Version

    1.2.13

    License

    MIT

    Unpacked Size

    86.3 kB

    Total Files

    9

    Last publish

    Collaborators

    • avatar
    • avatar