{\bfseries{Details}}

\begin{quote}
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) \end{quote}
Please consider following this project\textquotesingle{}s author, \href{https://github.com/jonschlinkert}{\texttt{ Jon Schlinkert}}, and consider starring the project to show your \+:heart\+: and support.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17894}{}\doxysection{Table of Contents}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17894}
$<$details$>$


\begin{DoxyItemize}
\item \href{\#install}{\texttt{ Install}}
\item \href{\#what-is-nanomatch}{\texttt{ What is nanomatch?}}
\item \href{\#getting-started}{\texttt{ Getting started}}
\begin{DoxyItemize}
\item \href{\#installing-nanomatch}{\texttt{ Installing nanomatch}}
\item \href{\#usage}{\texttt{ Usage}}
\end{DoxyItemize}
\item \href{\#documentation}{\texttt{ Documentation}}
\begin{DoxyItemize}
\item \href{\#escaping}{\texttt{ Escaping}}
\end{DoxyItemize}
\item \href{\#api}{\texttt{ API}}
\item \href{\#options}{\texttt{ Options}}
\begin{DoxyItemize}
\item \href{\#optionsbasename}{\texttt{ options.\+basename}}
\item \href{\#optionsbash}{\texttt{ options.\+bash}}
\item \href{\#optionscache}{\texttt{ options.\+cache}}
\item \href{\#optionsdot}{\texttt{ options.\+dot}}
\item \href{\#optionsfailglob}{\texttt{ options.\+failglob}}
\item \href{\#optionsignore}{\texttt{ options.\+ignore}}
\item \href{\#optionsmatchbase}{\texttt{ options.\+match\+Base}}
\item \href{\#optionsnocase}{\texttt{ options.\+nocase}}
\item \href{\#optionsnodupes}{\texttt{ options.\+nodupes}}
\item \href{\#optionsnoglobstar}{\texttt{ options.\+noglobstar}}
\item \href{\#optionsnonegate}{\texttt{ options.\+nonegate}}
\item \href{\#optionsnonull}{\texttt{ options.\+nonull}}
\item \href{\#optionsnullglob}{\texttt{ options.\+nullglob}}
\item \href{\#optionsslash}{\texttt{ options.\+slash}}
\item \href{\#optionsstar}{\texttt{ options.\+star}}
\item \href{\#optionssnapdragon}{\texttt{ options.\+snapdragon}}
\item \href{\#optionssourcemap}{\texttt{ options.\+sourcemap}}
\item \href{\#optionsunescape}{\texttt{ options.\+unescape}}
\item \href{\#optionsunixify}{\texttt{ options.\+unixify}}
\end{DoxyItemize}
\item \href{\#features}{\texttt{ Features}}
\item \href{\#bash-expansion-libs}{\texttt{ Bash expansion libs}}
\item \href{\#benchmarks}{\texttt{ Benchmarks}}
\begin{DoxyItemize}
\item \href{\#running-benchmarks}{\texttt{ Running benchmarks}}
\item \href{\#nanomatch-vs-minimatch-vs-multimatch}{\texttt{ Nanomatch vs. Minimatch vs. Multimatch}}
\end{DoxyItemize}
\item \href{\#about}{\texttt{ About}}
\end{DoxyItemize}

$<$/details$>$\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17895}{}\doxysection{Install}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17895}
Install with \href{https://www.npmjs.com/}{\texttt{ npm}}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install -\/-\/save nanomatch }

\end{DoxyCode}


$<$details$>$

{\bfseries{Release history}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17896}{}\doxysection{History}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17896}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17897}{}\doxysubsection{key}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17897}
Changelog entries are classified using the following labels \+\_\+(from \href{https://github.com/olivierlacan/keep-a-changelog}{\texttt{ keep-\/a-\/changelog}}\+\_\+)\+:


\begin{DoxyItemize}
\item {\ttfamily added}\+: for new features
\item {\ttfamily changed}\+: for changes in existing functionality
\item {\ttfamily deprecated}\+: for once-\/stable features removed in upcoming releases
\item {\ttfamily removed}\+: for deprecated features removed in this release
\item {\ttfamily fixed}\+: for any bug fixes
\item {\ttfamily bumped}\+: updated dependencies, only minor or higher will be listed.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17898}{}\doxysubsection{$<$a href=\char`\"{}https\+://github.\+com/micromatch/nanomatch/compare/1.\+0.\+4...\+1.\+1.\+0\char`\"{}$>$1.\+1.\+0$<$/a$>$ -\/ 2017-\/04-\/11}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17898}
{\bfseries{Fixed}}


\begin{DoxyItemize}
\item adds support for unclosed quotes
\end{DoxyItemize}

{\bfseries{Added}}


\begin{DoxyItemize}
\item adds support for {\ttfamily options.\+noglobstar}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17899}{}\doxysubsection{$<$a href=\char`\"{}https\+://github.\+com/micromatch/nanomatch/compare/1.\+0.\+3...\+1.\+0.\+4\char`\"{}$>$1.\+0.\+4$<$/a$>$ -\/ 2017-\/04-\/06}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17899}
Housekeeping updates. Adds documentation section about escaping, cleans up utils.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17900}{}\doxysubsection{$<$a href=\char`\"{}https\+://github.\+com/micromatch/nanomatch/compare/1.\+0.\+1...\+1.\+0.\+3\char`\"{}$>$1.\+0.\+3$<$/a$>$ -\/ 2017-\/04-\/06}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17900}
This release includes fixes for windows path edge cases and other improvements for stricter adherence to bash spec.

{\bfseries{Fixed}}


\begin{DoxyItemize}
\item More windows path edge cases
\end{DoxyItemize}

{\bfseries{Added}}


\begin{DoxyItemize}
\item Support for bash-\/like quoted strings for escaping sequences of characters, such as {\ttfamily foo/\char`\"{}$\ast$$\ast$\char`\"{}/bar} where {\ttfamily $\ast$$\ast$} should be matched literally and not evaluated as special characters.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17901}{}\doxysubsection{$<$a href=\char`\"{}https\+://github.\+com/micromatch/nanomatch/compare/1.\+0.\+0...\+1.\+0.\+1\char`\"{}$>$1.\+0.\+1$<$/a$>$ -\/ 2016-\/12-\/12}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17901}
{\bfseries{Added}}


\begin{DoxyItemize}
\item Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17902}{}\doxysubsection{$<$a href=\char`\"{}https\+://github.\+com/micromatch/nanomatch/compare/0.\+1.\+0...\+1.\+0.\+0\char`\"{}$>$1.\+0.\+0$<$/a$>$ -\/ 2016-\/12-\/12}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17902}
Stable release.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17903}{}\doxysubsection{\mbox{[}0.\+1.\+0\mbox{]} -\/ 2016-\/10-\/08}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17903}
First release.

$<$/details$>$\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17904}{}\doxysection{What is nanomatch?}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17904}
Nanomatch is a fast and accurate glob matcher with full support for standard Bash glob features, including the following \char`\"{}metacharacters\char`\"{}\+: {\ttfamily $\ast$}, {\ttfamily $\ast$$\ast$}, {\ttfamily ?} and {\ttfamily \mbox{[}...\mbox{]}}.

{\bfseries{Learn more}}


\begin{DoxyItemize}
\item \href{\#getting-started}{\texttt{ Getting started}}\+: learn how to install and begin using nanomatch
\item \href{\#features}{\texttt{ Features}}\+: jump to info about supported patterns, and a glob matching reference
\item \href{\#api}{\texttt{ API documentation}}\+: jump to available options and methods
\item \mbox{[}Unit tests\mbox{]}(test)\+: 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!
\end{DoxyItemize}

$<$details$>$

{\bfseries{How is this different?}} 

{\bfseries{Speed and accuracy}}

Nanomatch uses \href{https://github.com/jonschlinkert/snapdragon}{\texttt{ snapdragon}} for parsing and compiling globs, which results in\+:


\begin{DoxyItemize}
\item Granular control over the entire conversion process in a way that is easy to understand, reason about, and customize.
\item Faster matching, from a combination of optimized glob patterns and (optional) caching.
\item Much greater accuracy than minimatch. In fact, nanomatch passes {\itshape 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 \href{../../issues}{\texttt{ after researching previous issues}}, \href{../../issues/new}{\texttt{ please let us know}}.
\end{DoxyItemize}

{\bfseries{Basic globbing only}}

Nanomatch supports \href{\#features}{\texttt{ basic globbing only}}, which is limited to {\ttfamily $\ast$}, {\ttfamily $\ast$$\ast$}, {\ttfamily ?} and regex-\/like brackets.

If you need support for the other \href{\#bash-expansion-libs}{\texttt{ bash \char`\"{}expansion\char`\"{} types}} (in addition to the wildcard matching provided by nanomatch), consider using \href{https://github.com/micromatch/micromatch}{\texttt{ micromatch}} instead. \+\_\+(micromatch $>$=3.\+0.\+0 uses the nanomatch parser and compiler for basic glob matching)\+\_\+

$<$/details$>$\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17905}{}\doxysection{Getting started}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17905}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17906}{}\doxysubsection{Installing nanomatch}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17906}
{\bfseries{Install with \href{https://yarnpkg.com/}{\texttt{ yarn}}}}


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ yarn add nanomatch }

\end{DoxyCode}


{\bfseries{Install with \href{https://npmjs.com}{\texttt{ npm}}}}


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install nanomatch }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17907}{}\doxysubsection{Usage}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17907}
Add nanomatch to your project using node\textquotesingle{}s {\ttfamily require()} system\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{var nanomatch = require('nanomatch');}
\DoxyCodeLine{}
\DoxyCodeLine{// the main export is a function that takes an array of strings to match}
\DoxyCodeLine{// and a string or array of patterns to use for matching}
\DoxyCodeLine{nanomatch(list, patterns[, options]); }

\end{DoxyCode}


{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: List of strings to perform matches against. This is often a list of file paths.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more \href{\#features}{\texttt{ glob paterns}} to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Any \href{\#options}{\texttt{ supported options}} may be passed
\end{DoxyItemize}

{\bfseries{Examples}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{console.log(nm(['a', 'b/b', 'c/c/c'], '*'));}
\DoxyCodeLine{//=> ['a']}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm(['a', 'b/b', 'c/c/c'], '*/*'));}
\DoxyCodeLine{//=> ['b/b']}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm(['a', 'b/b', 'c/c/c'], '**'));}
\DoxyCodeLine{//=> ['a', 'b/b', 'c/c/c'] }

\end{DoxyCode}


See the \href{\#api}{\texttt{ API documentation}} for available methods and \href{https://github.com/einaros/options.js}{\texttt{ options}}.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17908}{}\doxysection{Documentation}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17908}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17909}{}\doxysubsection{Escaping}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17909}
{\itshape Backslashes and quotes} can be used to escape characters, forcing nanomatch to regard those characters as a literal characters.

{\bfseries{Backslashes}}

Use backslashes to escape single characters. For example, the following pattern would match {\ttfamily foo/$\ast$/bar} exactly\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{'foo/\(\backslash\)*/bar' }

\end{DoxyCode}


The following pattern would match {\ttfamily foo/} followed by a literal {\ttfamily $\ast$}, followed by zero or more of any characters besides {\ttfamily /}, followed by {\ttfamily /bar}.


\begin{DoxyCode}{0}
\DoxyCodeLine{'foo/\(\backslash\)**/bar' }

\end{DoxyCode}


{\bfseries{Quoted strings}}

Use single or double quotes to escape sequences of characters. For example, the following patterns would match {\ttfamily foo/$\ast$$\ast$/bar} exactly\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{'foo/"{}**"{}/bar'}
\DoxyCodeLine{'foo/\(\backslash\)'**\(\backslash\)'/bar'}
\DoxyCodeLine{"{}foo/'**'/bar"{} }

\end{DoxyCode}


{\bfseries{Matching literal quotes}}

If you need to match quotes literally, you can escape them as well. For example, the following will match {\ttfamily foo/\char`\"{}$\ast$\char`\"{}/bar}, {\ttfamily foo/\char`\"{}a\char`\"{}/bar}, {\ttfamily foo/\char`\"{}b\char`\"{}/bar}, or {\ttfamily foo/\char`\"{}c\char`\"{}/bar}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{'foo/\(\backslash\)\(\backslash\)"{}*\(\backslash\)\(\backslash\)"{}/bar' }

\end{DoxyCode}


And the following will match `foo/'$\ast$\textquotesingle{}/bar{\ttfamily ,}foo/\textquotesingle{}a\textquotesingle{}/bar{\ttfamily ,}foo/\textquotesingle{}b\textquotesingle{}/bar{\ttfamily , or}foo/\textquotesingle{}c\textquotesingle{}/bar\`{}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{'foo/\(\backslash\)\(\backslash\)\(\backslash\)'*\(\backslash\)\(\backslash\)\(\backslash\)'/bar' }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17910}{}\doxysection{API}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17910}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17911}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L40\char`\"{}$>$nanomatch$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17911}
The main function takes a list of strings and one or more glob patterns to use for matching.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: A list of strings to match
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: Returns an array of matches
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm(list, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm(['a.js', 'a.txt'], ['*.js']));}
\DoxyCodeLine{//=> [ 'a.js' ] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17912}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L106\char`\"{}$>$.\+match$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17912}
Similar to the main function, but {\ttfamily pattern} must be a string.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: Array of strings to match
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: Glob pattern to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: Returns an array of matches
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.match(list, pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));}
\DoxyCodeLine{//=> ['a.a', 'a.aa'] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17913}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L167\char`\"{}$>$.\+is\+Match$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17913}
Returns true if the specified {\ttfamily string} matches the given glob {\ttfamily pattern}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily string} $\ast$$\ast$\{String\}$\ast$$\ast$\+: String to match
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: Glob pattern to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if the string matches the glob pattern.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.isMatch(string, pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.isMatch('a.a', '*.a'));}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{console.log(nm.isMatch('a.b', '*.a'));}
\DoxyCodeLine{//=> false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17914}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L205\char`\"{}$>$.\+some$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17914}
Returns true if some of the elements in the given {\ttfamily list} match any of the given glob {\ttfamily patterns}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: The string or array of strings to test. Returns as soon as the first match is found.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if any patterns match {\ttfamily str}
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.some(list, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));}
\DoxyCodeLine{// true}
\DoxyCodeLine{console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));}
\DoxyCodeLine{// false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17915}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L243\char`\"{}$>$.\+every$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17915}
Returns true if every element in the given {\ttfamily list} matches at least one of the given glob {\ttfamily patterns}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: The string or array of strings to test.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if any patterns match {\ttfamily str}
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.every(list, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.every('foo.js', ['foo.js']));}
\DoxyCodeLine{// true}
\DoxyCodeLine{console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));}
\DoxyCodeLine{// true}
\DoxyCodeLine{console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));}
\DoxyCodeLine{// false}
\DoxyCodeLine{console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));}
\DoxyCodeLine{// false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17916}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L277\char`\"{}$>$.\+any$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17916}
Returns true if {\bfseries{any}} of the given glob {\ttfamily patterns} match the specified {\ttfamily string}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily str} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: The string to test.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if any patterns match {\ttfamily str}
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.any(string, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.any('a.a', ['b.*', '*.a']));}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{console.log(nm.any('a.a', 'b.*'));}
\DoxyCodeLine{//=> false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17917}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L325\char`\"{}$>$.\+all$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17917}
Returns true if {\bfseries{all}} of the given {\ttfamily patterns} match the specified string.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily str} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: The string to test.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if any patterns match {\ttfamily str}
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.all(string, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.all('foo.js', ['foo.js']));}
\DoxyCodeLine{// true}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.all('foo.js', ['*.js', '!foo.js']));}
\DoxyCodeLine{// false}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.all('foo.js', ['*.js', 'foo.js']));}
\DoxyCodeLine{// true}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));}
\DoxyCodeLine{// true }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17918}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L359\char`\"{}$>$.\+not$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17918}
Returns a list of strings that {\itshape {\bfseries{do not match any}}} of the given {\ttfamily patterns}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily list} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: Array of strings to match.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob pattern to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Array\}$\ast$$\ast$\+: Returns an array of strings that {\bfseries{do not match}} the given patterns.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.not(list, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));}
\DoxyCodeLine{//=> ['b.b', 'c.c'] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17919}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L394\char`\"{}$>$.\+contains$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17919}
Returns true if the given {\ttfamily string} contains the given pattern. Similar to \href{\#isMatch}{\texttt{ .is\+Match}} but the pattern can match any part of the string.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily str} $\ast$$\ast$\{String\}$\ast$$\ast$\+: The string to match.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: Glob pattern to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if the patter matches any part of {\ttfamily str}.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.contains(string, pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.contains('aa/bb/cc', '*b'));}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{console.log(nm.contains('aa/bb/cc', '*d'));}
\DoxyCodeLine{//=> false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17920}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L450\char`\"{}$>$.\+match\+Keys$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17920}
Filter the keys of the given object with the given {\ttfamily glob} pattern and {\ttfamily options}. Does not attempt to match nested keys. If you need this feature, use \href{https://github.com/jonschlinkert/glob-object}{\texttt{ glob-\/object}} instead.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily object} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: The object with keys to filter.
\item {\ttfamily patterns} $\ast$$\ast$\{String$\vert$\+Array\}$\ast$$\ast$\+: One or more glob patterns to use for matching.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns an object with only keys that match the given patterns.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.matchKeys(object, patterns[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{var obj = \{ aa: 'a', ab: 'b', ac: 'c' \};}
\DoxyCodeLine{console.log(nm.matchKeys(obj, '*b'));}
\DoxyCodeLine{//=> \{ ab: 'b' \} }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17921}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L479\char`\"{}$>$.\+matcher$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17921}
Returns a memoized matcher function from the given glob {\ttfamily pattern} and {\ttfamily options}. The returned function takes a string to match as its only argument and returns true if the string is a match.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: Glob pattern
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed.
\item {\ttfamily returns} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Returns a matcher function.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.matcher(pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{var isMatch = nm.matcher('*.!(*a)');}
\DoxyCodeLine{console.log(isMatch('a.a'));}
\DoxyCodeLine{//=> false}
\DoxyCodeLine{console.log(isMatch('a.b'));}
\DoxyCodeLine{//=> true }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17922}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L560\char`\"{}$>$.\+capture$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17922}
Returns an array of matches captured by {\ttfamily pattern} in {\ttfamily string, or}null\`{} if the pattern did not match.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: Glob pattern to use for matching.
\item {\ttfamily string} $\ast$$\ast$\{String\}$\ast$$\ast$\+: String to match
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns an array of captures if the string matches the glob pattern, otherwise {\ttfamily null}.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.capture(pattern, string[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.capture('test/*.js', 'test/foo.js'));}
\DoxyCodeLine{//=> ['foo']}
\DoxyCodeLine{console.log(nm.capture('test/*.js', 'foo/bar.css'));}
\DoxyCodeLine{//=> null }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17923}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L595\char`\"{}$>$.\+make\+Re$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17923}
Create a regular expression from the given glob {\ttfamily pattern}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: A glob pattern to convert to regex.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: See available \href{\#options}{\texttt{ options}} for changing how matches are performed.
\item {\ttfamily returns} $\ast$$\ast$\{Reg\+Exp\}$\ast$$\ast$\+: Returns a regex created from the given pattern.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.makeRe(pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{console.log(nm.makeRe('*.js'));}
\DoxyCodeLine{//=> /\string^(?:(\(\backslash\).[\(\backslash\)\(\backslash\)\(\backslash\)/])?(?!\(\backslash\).)(?=.)[\string^\(\backslash\)/]*?\(\backslash\).js)\$/ }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17924}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L658\char`\"{}$>$.\+create$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17924}
Parses the given glob {\ttfamily pattern} and returns an object with the compiled {\ttfamily output} and optional source {\ttfamily map}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily pattern} $\ast$$\ast$\{String\}$\ast$$\ast$\+: Glob pattern to parse and compile.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Any \href{\#options}{\texttt{ options}} to change how parsing and compiling is performed.
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns an object with the parsed AST, compiled string and optional source map.
\end{DoxyItemize}

{\bfseries{Example}}


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

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17925}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L697\char`\"{}$>$.\+parse$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17925}
Parse the given {\ttfamily str} with the given {\ttfamily options}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily str} $\ast$$\ast$\{String\}$\ast$$\ast$
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns an AST
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{nm.parse(pattern[, options]);}
\DoxyCodeLine{}
\DoxyCodeLine{var ast = nm.parse('a/\{b,c\}/d');}
\DoxyCodeLine{console.log(ast);}
\DoxyCodeLine{// \{ type: 'root',}
\DoxyCodeLine{//   errors: [],}
\DoxyCodeLine{//   input: 'a/\{b,c\}/d',}
\DoxyCodeLine{//   nodes:}
\DoxyCodeLine{//    [ \{ type: 'bos', val: '' \},}
\DoxyCodeLine{//      \{ type: 'text', val: 'a/' \},}
\DoxyCodeLine{//      \{ type: 'brace',}
\DoxyCodeLine{//        nodes:}
\DoxyCodeLine{//         [ \{ type: 'brace.open', val: '\{' \},}
\DoxyCodeLine{//           \{ type: 'text', val: 'b,c' \},}
\DoxyCodeLine{//           \{ type: 'brace.close', val: '\}' \} ] \},}
\DoxyCodeLine{//      \{ type: 'text', val: '/d' \},}
\DoxyCodeLine{//      \{ type: 'eos', val: '' \} ] \} }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17926}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L745\char`\"{}$>$.\+compile$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17926}
Compile the given {\ttfamily ast} or string with the given {\ttfamily options}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily ast} $\ast$$\ast$\{Object$\vert$\+String\}$\ast$$\ast$
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns an object that has an {\ttfamily output} property with the compiled string.
\end{DoxyItemize}

{\bfseries{Example}}


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

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17927}{}\doxysubsection{$<$a href=\char`\"{}index.\+js\#\+L768\char`\"{}$>$.\+clear\+Cache$<$/a$>$}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17927}
Clear the regex cache.

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{nm.clearCache(); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17928}{}\doxysection{Options}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17928}
$<$details$>$

{\bfseries{basename}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17929}{}\doxysubsection{options.\+basename}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17929}
Allow glob patterns without slashes to match a file path based on its basename. Same behavior as \href{https://github.com/isaacs/minimatch}{\texttt{ minimatch}} option {\ttfamily match\+Base}.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily false}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{nm(['a/b.js', 'a/c.md'], '*.js');}
\DoxyCodeLine{//=> []}
\DoxyCodeLine{}
\DoxyCodeLine{nm(['a/b.js', 'a/c.md'], '*.js', \{matchBase: true\});}
\DoxyCodeLine{//=> ['a/b.js'] }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{bash}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17930}{}\doxysubsection{options.\+bash}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17930}
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 {\bfseries{does not repeat the bracketed characters}}. Instead, the star is treated the same as an other star.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily true}

{\bfseries{Example}}


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

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{cache}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17931}{}\doxysubsection{options.\+cache}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17931}
Disable regex and function memoization.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{dot}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17932}{}\doxysubsection{options.\+dot}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17932}
Match dotfiles. Same behavior as \href{https://github.com/isaacs/minimatch}{\texttt{ minimatch}} option {\ttfamily dot}.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily false}

$<$/details$>$

$<$details$>$

{\bfseries{failglob}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17933}{}\doxysubsection{options.\+failglob}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17933}
Similar to the {\ttfamily -\/-\/failglob} behavior in Bash, throws an error when no matches are found.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{ignore}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17934}{}\doxysubsection{options.\+ignore}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17934}
String or array of glob patterns to match files to ignore.

Type\+: {\ttfamily String$\vert$\+Array}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{match\+Base}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17935}{}\doxysubsection{options.\+match\+Base}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17935}
Alias for \href{\#options-basename}{\texttt{ options.\+basename}}.

$<$/details$>$

$<$details$>$

{\bfseries{nocase}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17936}{}\doxysubsection{options.\+nocase}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17936}
Use a case-\/insensitive regex for matching files. Same behavior as \href{https://github.com/isaacs/minimatch}{\texttt{ minimatch}}.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{nodupes}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17937}{}\doxysubsection{options.\+nodupes}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17937}
Remove duplicate elements from the result array.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily true} (enabled by default)

{\bfseries{Example}}

Example of using the {\ttfamily unescape} and {\ttfamily nodupes} options together\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{nm.match(['a/b/c', 'a/b/c'], '**');}
\DoxyCodeLine{//=> ['abc']}
\DoxyCodeLine{}
\DoxyCodeLine{nm.match(['a/b/c', 'a/b/c'], '**', \{nodupes: false\});}
\DoxyCodeLine{//=> ['a/b/c', 'a/b/c'] }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{nonegate}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17938}{}\doxysubsection{options.\+noglobstar}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17938}
Disable matching with globstars ({\ttfamily $\ast$$\ast$}).

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}


\begin{DoxyCode}{0}
\DoxyCodeLine{nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**');}
\DoxyCodeLine{//=> ['a/b', 'a/b/c', 'a/b/c/d']}
\DoxyCodeLine{}
\DoxyCodeLine{nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', \{noglobstar: true\});}
\DoxyCodeLine{//=> ['a/b'] }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{nonegate}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17939}{}\doxysubsection{options.\+nonegate}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17939}
Disallow negation ({\ttfamily !}) patterns, and treat leading {\ttfamily !} as a literal character to match.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{nonull}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17940}{}\doxysubsection{options.\+nonull}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17940}
Alias for \href{\#options-nullglob}{\texttt{ options.\+nullglob}}.

$<$/details$>$

$<$details$>$

{\bfseries{nullglob}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17941}{}\doxysubsection{options.\+nullglob}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17941}
If {\ttfamily true}, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as \href{https://github.com/isaacs/minimatch}{\texttt{ minimatch}} option {\ttfamily nonull}.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{\label{_slash}%
slash}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17942}{}\doxysubsection{options.\+slash}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17942}
Customize the slash character(s) to use for matching.

Type\+: {\ttfamily string$\vert$function}

Default\+: {\ttfamily \mbox{[}/\textbackslash{}\textbackslash{}\mbox{]}} (forward slash and backslash)

$<$/details$>$

$<$details$>$

{\bfseries{\label{_star}%
star}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17943}{}\doxysubsection{options.\+star}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17943}
Customize the star character(s) to use for matching. It\textquotesingle{}s not recommended that you modify this unless you have advanced knowledge of the compiler and matching rules.

Type\+: {\ttfamily string$\vert$function}

Default\+: {\ttfamily \mbox{[}$^\wedge$/\textbackslash{}\textbackslash{}\mbox{]}$\ast$?}

$<$/details$>$

$<$details$>$

{\bfseries{\label{_snapdragon}%
snapdragon}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17944}{}\doxysubsection{options.\+snapdragon}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17944}
Pass your own instance of \href{https://github.com/jonschlinkert/snapdragon}{\texttt{ snapdragon}} to customize parsers or compilers.

Type\+: {\ttfamily object}

Default\+: {\ttfamily undefined}

$<$/details$>$

$<$details$>$

{\bfseries{snapdragon}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17945}{}\doxysubsection{options.\+sourcemap}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17945}
Generate a source map by enabling the {\ttfamily sourcemap} option with the {\ttfamily .parse}, {\ttfamily .compile}, or {\ttfamily .create} methods.

{\bfseries{Examples}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var nm = require('nanomatch');}
\DoxyCodeLine{}
\DoxyCodeLine{var res = nm.create('abc/*.js', \{sourcemap: true\});}
\DoxyCodeLine{console.log(res.map);}
\DoxyCodeLine{// \{ version: 3,}
\DoxyCodeLine{//   sources: [ 'string' ],}
\DoxyCodeLine{//   names: [],}
\DoxyCodeLine{//   mappings: 'AAAA,GAAG,EAAC,iBAAC,EAAC,EAAE',}
\DoxyCodeLine{//   sourcesContent: [ 'abc/*.js' ] \}}
\DoxyCodeLine{}
\DoxyCodeLine{var ast = nm.parse('abc/**/*.js');}
\DoxyCodeLine{var res = nm.compile(ast, \{sourcemap: true\});}
\DoxyCodeLine{console.log(res.map);}
\DoxyCodeLine{// \{ version: 3,}
\DoxyCodeLine{//   sources: [ 'string' ],}
\DoxyCodeLine{//   names: [],}
\DoxyCodeLine{//   mappings: 'AAAA,GAAG,EAAC,2BAAE,EAAC,iBAAC,EAAC,EAAE',}
\DoxyCodeLine{//   sourcesContent: [ 'abc/**/*.js' ] \} }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{unescape}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17946}{}\doxysubsection{options.\+unescape}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17946}
Remove backslashes from returned matches.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily undefined}

{\bfseries{Example}}

In this example we want to match a literal {\ttfamily $\ast$}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{nm.match(['abc', 'a\(\backslash\)\(\backslash\)*c'], 'a\(\backslash\)\(\backslash\)*c');}
\DoxyCodeLine{//=> ['a\(\backslash\)\(\backslash\)*c']}
\DoxyCodeLine{}
\DoxyCodeLine{nm.match(['abc', 'a\(\backslash\)\(\backslash\)*c'], 'a\(\backslash\)\(\backslash\)*c', \{unescape: true\});}
\DoxyCodeLine{//=> ['a*c'] }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{unixify}} \hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17947}{}\doxysubsection{options.\+unixify}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17947}
Convert path separators on returned files to posix/unix-\/style forward slashes.

Type\+: {\ttfamily boolean}

Default\+: {\ttfamily true}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{nm.match(['a\(\backslash\)\(\backslash\)b\(\backslash\)\(\backslash\)c'], 'a/**');}
\DoxyCodeLine{//=> ['a/b/c']}
\DoxyCodeLine{}
\DoxyCodeLine{nm.match(['a\(\backslash\)\(\backslash\)b\(\backslash\)\(\backslash\)c'], \{unixify: false\});}
\DoxyCodeLine{//=> ['a\(\backslash\)\(\backslash\)b\(\backslash\)\(\backslash\)c'] }

\end{DoxyCode}


$<$/details$>$\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17948}{}\doxysection{Features}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17948}
Nanomatch has full support for standard Bash glob features, including the following \char`\"{}metacharacters\char`\"{}\+: {\ttfamily $\ast$}, {\ttfamily $\ast$$\ast$}, {\ttfamily ?} and {\ttfamily \mbox{[}...\mbox{]}}.

Here are some examples of how they work\+:

\tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Pattern}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Description}}    }\\\cline{1-2}
\endfirsthead
\hline
\endfoot
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Pattern}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Description}}    }\\\cline{1-2}
\endhead
{\ttfamily $\ast$}   &Matches any string except for {\ttfamily /}, leading {\ttfamily .}, or {\ttfamily /.} inside a path   \\\cline{1-2}
\end{longtabu}
$\vert$ {\ttfamily $\ast$$\ast$} $\vert$ Matches any string including {\ttfamily /}, but not a leading {\ttfamily .} or {\ttfamily /.} inside a path. More than two stars (e.\+g. {\ttfamily $\ast$$\ast$$\ast$} is treated the same as one star, and {\ttfamily $\ast$$\ast$} loses its special meaning $\vert$ when it\textquotesingle{}s not the only thing in a path segment, per Bash specifications) $\vert$ $\vert$ {\ttfamily foo$\ast$} $\vert$ Matches any string beginning with {\ttfamily foo} $\vert$ $\vert$ {\ttfamily $\ast$bar$\ast$} $\vert$ Matches any string containing {\ttfamily bar} (beginning, middle or end) $\vert$ $\vert$ {\ttfamily $\ast$.min.\+js} $\vert$ Matches any string ending with {\ttfamily .min.\+js} $\vert$ $\vert$ {\ttfamily \mbox{[}abc\mbox{]}$\ast$.js} $\vert$ Matches any string beginning with {\ttfamily a}, {\ttfamily b}, or {\ttfamily c} and ending with {\ttfamily .js} $\vert$ $\vert$ {\ttfamily abc?} $\vert$ Matches {\ttfamily abcd} or {\ttfamily abcz} but not {\ttfamily abcde} $\vert$

The exceptions noted for {\ttfamily $\ast$} apply to all patterns that contain a {\ttfamily $\ast$}.

{\bfseries{Not supported}}

The following extended-\/globbing features are not supported\+:


\begin{DoxyItemize}
\item \href{https://github.com/jonschlinkert/braces}{\texttt{ brace expansion}} (e.\+g. {\ttfamily \{a,b,c\}})
\item \href{https://github.com/jonschlinkert/extglob}{\texttt{ extglobs}} (e.\+g. {\ttfamily @(a$\vert$!(c$\vert$d))})
\item \href{https://github.com/jonschlinkert/expand-brackets}{\texttt{ POSIX brackets}} (e.\+g. {\ttfamily \mbox{[}\mbox{[}\+:alpha\+:\mbox{]}\mbox{[}\+:digit\+:\mbox{]}\mbox{]}})
\end{DoxyItemize}

If you need any of these features consider using \href{https://github.com/micromatch/micromatch}{\texttt{ micromatch}} instead.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17949}{}\doxysection{Bash expansion libs}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17949}
Nanomatch is part of a suite of libraries aimed at bringing the power and expressiveness of \href{https://www.gnu.org/software/bash/}{\texttt{ Bash\textquotesingle{}s}} matching and expansion capabilities to Java\+Script, {\itshape and -\/ as you can see by the \href{\#benchmarks}{\texttt{ benchmarks}} -\/ without sacrificing speed}.

\tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{4}{|X[-1]}|}
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Related library}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Matching Type}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Example}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Description}}    }\\\cline{1-4}
\endfirsthead
\hline
\endfoot
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Related library}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Matching Type}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Example}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Description}}    }\\\cline{1-4}
\endhead
{\ttfamily nanomatch} (you are here)   &Wildcards   &{\ttfamily $\ast$}   &\href{https://www.gnu.org/software/bash/manual/html_node/Filename-Expansion.html\#Filename-Expansion}{\texttt{ Filename expansion}}, also referred to as globbing and pathname expansion, allows the use of \href{\#features}{\texttt{ wildcards}} for matching.    \\\cline{1-4}
\href{https://github.com/jonschlinkert/expand-tilde}{\texttt{ expand-\/tilde}}   &Tildes   &{\ttfamily $\sim$}   &\href{https://www.gnu.org/software/bash/manual/html_node/Tilde-Expansion.html\#Tilde-Expansion}{\texttt{ Tilde expansion}} converts the leading tilde in a file path to the user home directory.    \\\cline{1-4}
\href{https://github.com/jonschlinkert/braces}{\texttt{ braces}}   &Braces   &{\ttfamily \{a,b,c\}}   &\href{https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html}{\texttt{ Brace expansion}}    \\\cline{1-4}
\href{https://github.com/jonschlinkert/expand-brackets}{\texttt{ expand-\/brackets}}   &Brackets   &{\ttfamily \mbox{[}\mbox{[}\+:alpha\+:\mbox{]}\mbox{]}}   &\href{https://www.gnu.org/software/grep/manual/html_node/Character-Classes-and-Bracket-Expressions.html}{\texttt{ POSIX character classes}} (also referred to as POSIX brackets, or POSIX character classes)   \\\cline{1-4}
\end{longtabu}
$\vert$ \href{https://github.com/jonschlinkert/extglob}{\texttt{ extglob}} $\vert$ Parens $\vert$ {\ttfamily !(a\textbackslash{} $\vert$ b)} $\vert$ \href{https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html\#Pattern-Matching}{\texttt{ Extglobs}} $\vert$ $\vert$ \href{https://github.com/micromatch/micromatch}{\texttt{ micromatch}} $\vert$ All $\vert$ all $\vert$ Micromatch is built on top of the other libraries. $\vert$

There are many resources available on the web if you want to dive deeper into how these features work in Bash.\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17950}{}\doxysection{Benchmarks}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17950}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17951}{}\doxysubsection{Running benchmarks}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17951}
Install dev dependencies\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{npm i -\/d \&\& node benchmark }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17952}{}\doxysubsection{Nanomatch vs. Minimatch vs. Multimatch}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17952}

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

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17953}{}\doxysection{About}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17953}
$<$details$>$

{\bfseries{Contributing}} 

Pull requests and stars are always welcome. For bugs and feature requests, \href{../../issues/new}{\texttt{ please create an issue}}.

Please read the contributing guide for advice on opening issues, pull requests, and coding standards.

$<$/details$>$

$<$details$>$

{\bfseries{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\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install \&\& npm test }

\end{DoxyCode}


$<$/details$>$

$<$details$>$

{\bfseries{Building docs}} 

\+\_\+(This project\textquotesingle{}s readme.\+md is generated by \href{https://github.com/verbose/verb-generate-readme}{\texttt{ verb}}, please don\textquotesingle{}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\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install -\/g verbose/verb\#dev verb-\/generate-\/readme \&\& verb }

\end{DoxyCode}


$<$/details$>$\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17954}{}\doxysubsection{Related projects}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17954}
You might also be interested in these projects\+:


\begin{DoxyItemize}
\item \href{https://www.npmjs.com/package/extglob}{\texttt{ extglob}}\+: Extended glob support for Java\+Script. Adds (almost) the expressive power of regular expressions to glob… \href{https://github.com/micromatch/extglob}{\texttt{ more}} $\vert$ \mbox{[}homepage\mbox{]}(\href{https://github.com/micromatch/extglob}{\texttt{ https\+://github.\+com/micromatch/extglob}} \char`\"{}\+Extended glob support for Java\+Script. Adds (almost) the expressive power of regular expressions to glob patterns.\char`\"{})
\item \href{https://www.npmjs.com/package/is-extglob}{\texttt{ is-\/extglob}}\+: Returns true if a string has an extglob. $\vert$ \href{https://github.com/jonschlinkert/is-extglob}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/is-glob}{\texttt{ is-\/glob}}\+: Returns {\ttfamily true} if the given string looks like a glob pattern or an extglob pattern… \href{https://github.com/jonschlinkert/is-glob}{\texttt{ more}} $\vert$ \href{https://github.com/jonschlinkert/is-glob}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/micromatch}{\texttt{ micromatch}}\+: Glob matching for javascript/node.\+js. A drop-\/in replacement and faster alternative to minimatch and multimatch. $\vert$ \href{https://github.com/micromatch/micromatch}{\texttt{ homepage}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17955}{}\doxysubsection{Contributors}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17955}
\tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Commits}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Contributor}}    }\\\cline{1-2}
\endfirsthead
\hline
\endfoot
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Commits}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Contributor}}    }\\\cline{1-2}
\endhead
164   &\href{https://github.com/jonschlinkert}{\texttt{ jonschlinkert}}    \\\cline{1-2}
1   &\href{https://github.com/devongovett}{\texttt{ devongovett}}   \\\cline{1-2}
\end{longtabu}
\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17956}{}\doxysubsection{Author}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17956}
{\bfseries{Jon Schlinkert}}


\begin{DoxyItemize}
\item \href{https://linkedin.com/in/jonschlinkert}{\texttt{ linkedin/in/jonschlinkert}}
\item \href{https://github.com/jonschlinkert}{\texttt{ github/jonschlinkert}}
\item \href{https://twitter.com/jonschlinkert}{\texttt{ twitter/jonschlinkert}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_nanomatch_README_autotoc_md17957}{}\doxysubsection{License}\label{md_sfcode_node_modules_nanomatch_README_autotoc_md17957}
Copyright © 2018, \href{https://github.com/jonschlinkert}{\texttt{ Jon Schlinkert}}. Released under the \mbox{[}MIT License\mbox{]}(LICENSE).

\DoxyHorRuler{0}


{\itshape This file was generated by \href{https://github.com/verbose/verb-generate-readme}{\texttt{ verb-\/generate-\/readme}}, v0.\+6.\+0, on February 18, 2018.} 