\tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{0}{|X[-1]}|}
\hline
\end{longtabu}


Linux 

OS X 

Windows 

Coverage 

Downloads  $<$/thead$>$$<$tbody$>$

\href{https://travis-ci.org/kaelzhang/node-ignore}{\texttt{ }}  

\href{https://ci.appveyor.com/project/kaelzhang/node-ignore}{\texttt{ }}  

\href{https://codecov.io/gh/kaelzhang/node-ignore}{\texttt{ }}  

\href{https://www.npmjs.org/package/ignore}{\texttt{ }}  $<$/tbody$>$\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12616}{}\doxysection{ignore}\label{md_sfcode_node_modules_ignore_README_autotoc_md12616}
{\ttfamily ignore} is a manager, filter and parser which implemented in pure Java\+Script according to the \href{http://git-scm.com/docs/gitignore}{\texttt{ .gitignore spec 2.\+22.\+1}}.

{\ttfamily ignore} is used by eslint, gitbook and \href{https://www.npmjs.com/browse/depended/ignore}{\texttt{ many others}}.

Pay {\bfseries{ATTENTION}} that \href{https://www.npmjs.org/package/minimatch}{\texttt{ {\ttfamily minimatch}}} (which used by {\ttfamily fstream-\/ignore}) does not follow the gitignore spec.

To filter filenames according to a .gitignore file, I recommend this npm package, {\ttfamily ignore}.

To parse an {\ttfamily .npmignore} file, you should use {\ttfamily minimatch}, because an {\ttfamily .npmignore} file is parsed by npm using {\ttfamily minimatch} and it does not work in the .gitignore way.\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12617}{}\doxysubsubsection{Tested on}\label{md_sfcode_node_modules_ignore_README_autotoc_md12617}
{\ttfamily ignore} is fully tested, and has more than {\bfseries{five hundreds}} of unit tests.


\begin{DoxyItemize}
\item Linux + Node\+: {\ttfamily 0.\+8} -\/ {\ttfamily 7.\+x}
\item Windows + Node\+: {\ttfamily 0.\+10} -\/ {\ttfamily 7.\+x}, node $<$ {\ttfamily 0.\+10} is not tested due to the lack of support of appveyor.
\end{DoxyItemize}

Actually, {\ttfamily ignore} does not rely on any versions of node specially.

Since {\ttfamily 4.\+0.\+0}, ignore will no longer support {\ttfamily node $<$ 6} by default, to use in node $<$ 6, `require(\textquotesingle{}ignore/legacy')\`{}. For details, see \href{https://github.com/kaelzhang/node-ignore/blob/master/CHANGELOG.md}{\texttt{ CHANGELOG}}.\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12618}{}\doxysubsection{Table Of Main Contents}\label{md_sfcode_node_modules_ignore_README_autotoc_md12618}

\begin{DoxyItemize}
\item \href{\#usage}{\texttt{ Usage}}
\item \href{\#pathname-conventions}{\texttt{ {\ttfamily Pathname} Conventions}}
\item See Also\+:
\begin{DoxyItemize}
\item \href{https://www.npmjs.com/package/glob-gitignore}{\texttt{ {\ttfamily glob-\/gitignore}}} matches files using patterns and filters them according to gitignore rules.
\end{DoxyItemize}
\item \href{\#upgrade-guide}{\texttt{ Upgrade Guide}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12619}{}\doxysubsection{Install}\label{md_sfcode_node_modules_ignore_README_autotoc_md12619}

\begin{DoxyCode}{0}
\DoxyCodeLine{npm i ignore }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12620}{}\doxysubsection{Usage}\label{md_sfcode_node_modules_ignore_README_autotoc_md12620}

\begin{DoxyCode}{0}
\DoxyCodeLine{import ignore from 'ignore'}
\DoxyCodeLine{const ig = ignore().add(['.abc/*', '!.abc/d/']) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12621}{}\doxysubsubsection{Filter the given paths}\label{md_sfcode_node_modules_ignore_README_autotoc_md12621}

\begin{DoxyCode}{0}
\DoxyCodeLine{const paths = [}
\DoxyCodeLine{  '.abc/a.js',    // filtered out}
\DoxyCodeLine{  '.abc/d/e.js'   // included}
\DoxyCodeLine{]}
\DoxyCodeLine{}
\DoxyCodeLine{ig.filter(paths)        // ['.abc/d/e.js']}
\DoxyCodeLine{ig.ignores('.abc/a.js') // true }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12622}{}\doxysubsubsection{As the filter function}\label{md_sfcode_node_modules_ignore_README_autotoc_md12622}

\begin{DoxyCode}{0}
\DoxyCodeLine{paths.filter(ig.createFilter()); // ['.abc/d/e.js'] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12623}{}\doxysubsubsection{Win32 paths will be handled}\label{md_sfcode_node_modules_ignore_README_autotoc_md12623}

\begin{DoxyCode}{0}
\DoxyCodeLine{ig.filter(['.abc\(\backslash\)\(\backslash\)a.js', '.abc\(\backslash\)\(\backslash\)d\(\backslash\)\(\backslash\)e.js'])}
\DoxyCodeLine{// if the code above runs on windows, the result will be}
\DoxyCodeLine{// ['.abc\(\backslash\)\(\backslash\)d\(\backslash\)\(\backslash\)e.js'] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12624}{}\doxysubsection{Why another ignore?}\label{md_sfcode_node_modules_ignore_README_autotoc_md12624}

\begin{DoxyItemize}
\item {\ttfamily ignore} is a standalone module, and is much simpler so that it could easy work with other programs, unlike \href{https://npmjs.org/~isaacs}{\texttt{ isaacs}}\textquotesingle{}s \href{https://npmjs.org/package/fstream-ignore}{\texttt{ fstream-\/ignore}} which must work with the modules of the fstream family.
\item {\ttfamily ignore} only contains utility methods to filter paths according to the specified ignore rules, so
\begin{DoxyItemize}
\item {\ttfamily ignore} never try to find out ignore rules by traversing directories or fetching from git configurations.
\item {\ttfamily ignore} don\textquotesingle{}t cares about sub-\/modules of git projects.
\end{DoxyItemize}
\item Exactly according to \href{http://git-scm.com/docs/gitignore}{\texttt{ gitignore man page}}, fixes some known matching issues of fstream-\/ignore, such as\+:
\begin{DoxyItemize}
\item \textquotesingle{}{\ttfamily /$\ast$.js}\textquotesingle{} should only match \textquotesingle{}{\ttfamily a.\+js}\textquotesingle{}, but not \textquotesingle{}{\ttfamily abc/a.\+js}\textquotesingle{}.
\item \textquotesingle{}{\ttfamily $\ast$$\ast$/foo}\textquotesingle{} should match \textquotesingle{}{\ttfamily foo}\textquotesingle{} anywhere.
\item Prevent re-\/including a file if a parent directory of that file is excluded.
\item Handle trailing whitespaces\+:
\begin{DoxyItemize}
\item `\textquotesingle{}a '{\ttfamily (one space) should not match}\textquotesingle{}a \textquotesingle{}{\ttfamily (two spaces). -\/}\textquotesingle{}a \textbackslash{} \textquotesingle{}{\ttfamily matches}\textquotesingle{}a \textquotesingle{}{\ttfamily }
\end{DoxyItemize}
\item {\ttfamily All test cases are verified with the result of}git check-\/ignore\`{}.
\end{DoxyItemize}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12625}{}\doxysection{Methods}\label{md_sfcode_node_modules_ignore_README_autotoc_md12625}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12626}{}\doxysubsection{.\+add(pattern\+: string $\vert$ Ignore)\+: this}\label{md_sfcode_node_modules_ignore_README_autotoc_md12626}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12627}{}\doxysubsection{.\+add(patterns\+: Array$<$string $\vert$ Ignore$>$)\+: this}\label{md_sfcode_node_modules_ignore_README_autotoc_md12627}

\begin{DoxyItemize}
\item {\bfseries{pattern}} {\ttfamily String $\vert$ Ignore} An ignore pattern string, or the {\ttfamily Ignore} instance
\item {\bfseries{patterns}} {\ttfamily Array$<$String $\vert$ Ignore$>$} Array of ignore patterns.
\end{DoxyItemize}

Adds a rule or several rules to the current manager.

Returns {\ttfamily this}

Notice that a line starting with `'\#\textquotesingle{}{\ttfamily (hash) is treated as a comment. Put a backslash (}\textquotesingle{}\textbackslash{}\textquotesingle{}\`{}) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.


\begin{DoxyCode}{0}
\DoxyCodeLine{ignore().add('\#abc').ignores('\#abc')    // false}
\DoxyCodeLine{ignore().add('\(\backslash\)\#abc').ignores('\#abc')   // true }

\end{DoxyCode}


{\ttfamily pattern} could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just {\ttfamily ignore().add()} the content of a ignore file\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{ignore()}
\DoxyCodeLine{.add(fs.readFileSync(filenameOfGitignore).toString())}
\DoxyCodeLine{.filter(filenames) }

\end{DoxyCode}


{\ttfamily pattern} could also be an {\ttfamily ignore} instance, so that we could easily inherit the rules of another {\ttfamily Ignore} instance.\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12628}{}\doxysubsection{$<$strike$>$.\+add\+Ignore\+File(path)$<$/strike$>$}\label{md_sfcode_node_modules_ignore_README_autotoc_md12628}
REMOVED in {\ttfamily 3.\+x} for now.

To upgrade {\ttfamily ignore@2.\+x} up to {\ttfamily 3.\+x}, use


\begin{DoxyCode}{0}
\DoxyCodeLine{import fs from 'fs'}
\DoxyCodeLine{}
\DoxyCodeLine{if (fs.existsSync(filename)) \{}
\DoxyCodeLine{  ignore().add(fs.readFileSync(filename).toString())}
\DoxyCodeLine{\} }

\end{DoxyCode}


instead.\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12629}{}\doxysubsection{.\+filter(paths\+: Array$<$\+Pathname$>$)\+: Array$<$\+Pathname$>$}\label{md_sfcode_node_modules_ignore_README_autotoc_md12629}

\begin{DoxyCode}{0}
\DoxyCodeLine{type Pathname = string }

\end{DoxyCode}


Filters the given array of pathnames, and returns the filtered array.


\begin{DoxyItemize}
\item {\bfseries{paths}} {\ttfamily Array.$<$Pathname$>$} The array of {\ttfamily pathname}s to be filtered.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12630}{}\doxysubsubsection{$<$tt$>$\+Pathname$<$/tt$>$ Conventions\+:}\label{md_sfcode_node_modules_ignore_README_autotoc_md12630}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12631}{}\doxyparagraph{1. $<$tt$>$\+Pathname$<$/tt$>$ should be a $<$tt$>$path.\+relative()$<$/tt$>$d pathname}\label{md_sfcode_node_modules_ignore_README_autotoc_md12631}
{\ttfamily Pathname} should be a string that have been {\ttfamily path.\+join()}ed, or the return value of {\ttfamily path.\+relative()} to the current directory,


\begin{DoxyCode}{0}
\DoxyCodeLine{// WRONG, an error will be thrown}
\DoxyCodeLine{ig.ignores('./abc')}
\DoxyCodeLine{}
\DoxyCodeLine{// WRONG, for it will never happen, and an error will be thrown}
\DoxyCodeLine{// If the gitignore rule locates at the root directory,}
\DoxyCodeLine{// `'/abc'` should be changed to `'abc'`.}
\DoxyCodeLine{// }

\end{DoxyCode}
 // path.\+relative(\textquotesingle{}/\textquotesingle{}, \textquotesingle{}/abc\textquotesingle{}) -\/$>$ \textquotesingle{}abc\textquotesingle{} // \`{}\`{}` ig.\+ignores('/abc\textquotesingle{})

// WRONG, that it is an absolute path on Windows, an error will be thrown ig.\+ignores(\textquotesingle{}C\+:\textbackslash{}abc\textquotesingle{})

// Right ig.\+ignores(\textquotesingle{}abc\textquotesingle{})

// Right ig.\+ignores(path.\+join(\textquotesingle{}./abc\textquotesingle{})) // path.\+join(\textquotesingle{}./abc\textquotesingle{}) -\/$>$ \textquotesingle{}abc\textquotesingle{} 
\begin{DoxyCode}{0}
\DoxyCodeLine{In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.}
\DoxyCodeLine{}
\DoxyCodeLine{Suppose the dir structure is:}

\end{DoxyCode}
 /path/to/your/repo $\vert$-- a $\vert$ $\vert$-- a.\+js $\vert$ $\vert$-- .b $\vert$ $\vert$-- .c $\vert$-- .DS\+\_\+store 
\begin{DoxyCode}{0}
\DoxyCodeLine{Then the `paths` might be like this:}
\DoxyCodeLine{}
\DoxyCodeLine{```js}
\DoxyCodeLine{[}
\DoxyCodeLine{  'a/a.js'}
\DoxyCodeLine{  '.b',}
\DoxyCodeLine{  '.c/.DS\_store'}
\DoxyCodeLine{] }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12632}{}\doxyparagraph{2. filenames and dirnames}\label{md_sfcode_node_modules_ignore_README_autotoc_md12632}
{\ttfamily node-\/ignore} does NO {\ttfamily fs.\+stat} during path matching, so for the example below\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{// First, we add a ignore pattern to ignore a directory}
\DoxyCodeLine{ig.add('config/')}
\DoxyCodeLine{}
\DoxyCodeLine{// `ig` does NOT know if 'config', in the real world,}
\DoxyCodeLine{//   is a normal file, directory or something.}
\DoxyCodeLine{}
\DoxyCodeLine{ig.ignores('config')}
\DoxyCodeLine{// `ig` treats `config` as a file, so it returns `false`}
\DoxyCodeLine{}
\DoxyCodeLine{ig.ignores('config/')}
\DoxyCodeLine{// returns `true` }

\end{DoxyCode}


Specially for people who develop some library based on {\ttfamily node-\/ignore}, it is important to understand that.

Usually, you could use \href{http://npmjs.org/package/glob}{\texttt{ {\ttfamily glob}}} with {\ttfamily option.\+mark = true} to fetch the structure of the current directory\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{import glob from 'glob'}
\DoxyCodeLine{}
\DoxyCodeLine{glob('**', \{}
\DoxyCodeLine{  // Adds a / character to directory matches.}
\DoxyCodeLine{  mark: true}
\DoxyCodeLine{\}, (err, files) => \{}
\DoxyCodeLine{  if (err) \{}
\DoxyCodeLine{    return console.error(err)}
\DoxyCodeLine{  \}}
\DoxyCodeLine{}
\DoxyCodeLine{  let filtered = ignore().add(patterns).filter(files)}
\DoxyCodeLine{  console.log(filtered)}
\DoxyCodeLine{\}) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12633}{}\doxysubsection{.\+ignores(pathname\+: Pathname)\+: boolean}\label{md_sfcode_node_modules_ignore_README_autotoc_md12633}
\begin{quote}
new in 3.\+2.\+0 \end{quote}
Returns {\ttfamily Boolean} whether {\ttfamily pathname} should be ignored.


\begin{DoxyCode}{0}
\DoxyCodeLine{ig.ignores('.abc/a.js')    // true }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12634}{}\doxysubsection{.\+create\+Filter()}\label{md_sfcode_node_modules_ignore_README_autotoc_md12634}
Creates a filter function which could filter an array of paths with {\ttfamily Array.\+prototype.\+filter}.

Returns {\ttfamily function(path)} the filter function.\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12635}{}\doxysubsection{.\+test(pathname\+: Pathname) since 5.\+0.\+0}\label{md_sfcode_node_modules_ignore_README_autotoc_md12635}
Returns {\ttfamily Test\+Result}


\begin{DoxyCode}{0}
\DoxyCodeLine{interface TestResult \{}
\DoxyCodeLine{  ignored: boolean}
\DoxyCodeLine{  // true if the `pathname` is finally unignored by some negative pattern}
\DoxyCodeLine{  unignored: boolean}
\DoxyCodeLine{\} }

\end{DoxyCode}



\begin{DoxyItemize}
\item {\ttfamily \{ignored\+: true, unignored\+: false\}}\+: the {\ttfamily pathname} is ignored
\item {\ttfamily \{ignored\+: false, unignored\+: true\}}\+: the {\ttfamily pathname} is unignored
\item {\ttfamily \{ignored\+: false, unignored\+: false\}}\+: the {\ttfamily pathname} is never matched by any ignore rules.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12636}{}\doxysubsection{$<$tt$>$options.\+ignorecase$<$/tt$>$ since 4.\+0.\+0}\label{md_sfcode_node_modules_ignore_README_autotoc_md12636}
Similar as the {\ttfamily core.\+ignorecase} option of \href{https://git-scm.com/docs/git-config}{\texttt{ git-\/config}}, {\ttfamily node-\/ignore} will be case insensitive if {\ttfamily options.\+ignorecase} is set to {\ttfamily true} (the default value), otherwise case sensitive.


\begin{DoxyCode}{0}
\DoxyCodeLine{const ig = ignore(\{}
\DoxyCodeLine{  ignorecase: false}
\DoxyCodeLine{\})}
\DoxyCodeLine{}
\DoxyCodeLine{ig.add('*.png')}
\DoxyCodeLine{}
\DoxyCodeLine{ig.ignores('*.PNG')  // false }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12637}{}\doxysubsection{static $<$tt$>$ignore.\+is\+Path\+Valid(pathname)\+: boolean$<$/tt$>$ since 5.\+0.\+0}\label{md_sfcode_node_modules_ignore_README_autotoc_md12637}
Check whether the {\ttfamily pathname} is an valid {\ttfamily path.\+relative()}d path according to the \href{\#1-pathname-should-be-a-pathrelatived-pathname}{\texttt{ convention}}.

This method is {\bfseries{NOT}} used to check if an ignore pattern is valid.


\begin{DoxyCode}{0}
\DoxyCodeLine{ignore.isPathValid('./foo')  // false }

\end{DoxyCode}


\DoxyHorRuler{0}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12638}{}\doxysection{Upgrade Guide}\label{md_sfcode_node_modules_ignore_README_autotoc_md12638}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12639}{}\doxysubsection{Upgrade 4.\+x -\/$>$ 5.\+x}\label{md_sfcode_node_modules_ignore_README_autotoc_md12639}
Since {\ttfamily 5.\+0.\+0}, if an invalid {\ttfamily Pathname} passed into {\ttfamily ig.\+ignores()}, an error will be thrown, while {\ttfamily ignore $<$ 5.\+0.\+0} did not make sure what the return value was, as well as


\begin{DoxyCode}{0}
\DoxyCodeLine{.ignores(pathname: Pathname): boolean}
\DoxyCodeLine{}
\DoxyCodeLine{.filter(pathnames: Array<Pathname>): Array<Pathname>}
\DoxyCodeLine{}
\DoxyCodeLine{.createFilter(): (pathname: Pathname) => boolean}
\DoxyCodeLine{}
\DoxyCodeLine{.test(pathname: Pathname): \{ignored: boolean, unignored: boolean\} }

\end{DoxyCode}


See the convention \href{\#1-pathname-should-be-a-pathrelatived-pathname}{\texttt{ here}} for details.

If there are invalid pathnames, the conversion and filtration should be done by users.


\begin{DoxyCode}{0}
\DoxyCodeLine{import \{isPathValid\} from 'ignore' // introduced in 5.0.0}
\DoxyCodeLine{}
\DoxyCodeLine{const paths = [}
\DoxyCodeLine{  // invalid}
\DoxyCodeLine{  //////////////////}
\DoxyCodeLine{  '',}
\DoxyCodeLine{  false,}
\DoxyCodeLine{  '../foo',}
\DoxyCodeLine{  '.',}
\DoxyCodeLine{  //////////////////}
\DoxyCodeLine{}
\DoxyCodeLine{  // valid}
\DoxyCodeLine{  'foo'}
\DoxyCodeLine{]}
\DoxyCodeLine{.filter(isValidPath)}
\DoxyCodeLine{}
\DoxyCodeLine{ig.filter(paths) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12640}{}\doxysubsection{Upgrade 3.\+x -\/$>$ 4.\+x}\label{md_sfcode_node_modules_ignore_README_autotoc_md12640}
Since {\ttfamily 4.\+0.\+0}, {\ttfamily ignore} will no longer support node $<$ 6, to use {\ttfamily ignore} in node $<$ 6\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{var ignore = require('ignore/legacy') }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12641}{}\doxysubsection{Upgrade 2.\+x -\/$>$ 3.\+x}\label{md_sfcode_node_modules_ignore_README_autotoc_md12641}

\begin{DoxyItemize}
\item All {\ttfamily options} of 2.\+x are unnecessary and removed, so just remove them.
\item {\ttfamily ignore()} instance is no longer an \href{nodejs.org/api/events.html}{\texttt{ {\ttfamily Event\+Emitter}}}, and all events are unnecessary and removed.
\item {\ttfamily .add\+Ignore\+File()} is removed, see the \href{\#addignorefilepath}{\texttt{ .add\+Ignore\+File}} section for details.
\end{DoxyItemize}

\DoxyHorRuler{0}
\hypertarget{md_sfcode_node_modules_ignore_README_autotoc_md12642}{}\doxysection{Collaborators}\label{md_sfcode_node_modules_ignore_README_autotoc_md12642}

\begin{DoxyItemize}
\item \href{https://github.com/whitecolor}{\texttt{ @whitecolor}} {\itshape Alex}
\item \href{https://github.com/SamyPesse}{\texttt{ @\+Samy\+Pesse}} {\itshape Samy Pessé}
\item \href{https://github.com/azproduction}{\texttt{ @azproduction}} {\itshape Mikhail Davydov}
\item \href{https://github.com/TrySound}{\texttt{ @\+Try\+Sound}} {\itshape Bogdan Chadkin}
\item \href{https://github.com/JanMattner}{\texttt{ @\+Jan\+Mattner}} {\itshape Jan Mattner}
\item \href{https://github.com/ntwb}{\texttt{ @ntwb}} {\itshape Stephen Edgar}
\item \href{https://github.com/kasperisager}{\texttt{ @kasperisager}} {\itshape Kasper Isager}
\item \href{https://github.com/sandersn}{\texttt{ @sandersn}} {\itshape Nathan Shively-\/\+Sanders} 
\end{DoxyItemize}