\href{https://travis-ci.org/anodynos/upath}{\texttt{ }} \href{https://david-dm.org/anodynos/upath}{\texttt{ }}

A drop-\/in replacement / proxy to nodejs\textquotesingle{}s {\ttfamily path} that\+:


\begin{DoxyItemize}
\item Replaces the windows {\ttfamily \textbackslash{}} with the unix {\ttfamily /} in all string params \& results. This has significant positives -\/ see below.
\item Adds {\bfseries{filename extensions}} functions {\ttfamily add\+Ext}, {\ttfamily trim\+Ext}, {\ttfamily remove\+Ext}, {\ttfamily change\+Ext}, and {\ttfamily default\+Ext}.
\item Add a {\ttfamily normalize\+Safe} function to preserve any meaningful leading {\ttfamily ./} \& a {\ttfamily normalize\+Trim} which additionally trims any useless ending {\ttfamily /}.
\item Plus a helper {\ttfamily to\+Unix} that simply converts {\ttfamily \textbackslash{}} to {\ttfamily /} and consolidates duplicates.
\end{DoxyItemize}

{\bfseries{Useful note\+: these docs are actually auto generated from \href{https://github.com/anodynos/upath/blob/master/source/spec/upath-spec.coffee}{\texttt{ specs}}, running on Linux.}}

Notes\+:


\begin{DoxyItemize}
\item {\ttfamily upath.\+sep} is set to `'/\textquotesingle{}\`{} for seamless replacement (as of 1.\+0.\+3).
\item upath has no runtime dependencies, except built-\/in {\ttfamily path} (as of 1.\+0.\+4)
\item travis-\/ci tested in node versions 4 to 12
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31543}{}\doxysection{Why ?}\label{md_sfcode_node_modules_upath_readme_autotoc_md31543}
Normal {\ttfamily path} doesn\textquotesingle{}t convert paths to a unified format (ie {\ttfamily /}) before calculating paths ({\ttfamily normalize}, {\ttfamily join}), which can lead to numerous problems. Also path joining, normalization etc on the two formats is not consistent, depending on where it runs. Running {\ttfamily path} on Windows yields different results than when it runs on Linux / Mac.

In general, if you code your paths logic while developing on Unix/\+Mac and it runs on Windows, you may run into problems when using {\ttfamily path}.

Note that using {\bfseries{Unix {\ttfamily /} on Windows}} works perfectly inside nodejs (and other languages), so there\textquotesingle{}s no reason to stick to the Windows legacy at all.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31544}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31544}
Check out the different (improved) behavior to vanilla {\ttfamily path}\+: \begin{DoxyVerb}`upath.normalize(path)`        --returns-->

      ✓ `'c:/windows/nodejs/path'`           --->      `'c:/windows/nodejs/path'`  // equal to `path.normalize()`
      ✓ `'c:/windows/../nodejs/path'`        --->              `'c:/nodejs/path'`  // equal to `path.normalize()`
      ✓ `'c:\\windows\\nodejs\\path'`        --->      `'c:/windows/nodejs/path'`  // `path.normalize()` gives `'c:\windows\nodejs\path'`
      ✓ `'c:\\windows\\..\\nodejs\\path'`    --->              `'c:/nodejs/path'`  // `path.normalize()` gives `'c:\windows\..\nodejs\path'`
      ✓ `'//windows\\unix/mixed'`            --->         `'/windows/unix/mixed'`  // `path.normalize()` gives `'/windows\unix/mixed'`
      ✓ `'\\windows//unix/mixed'`            --->         `'/windows/unix/mixed'`  // `path.normalize()` gives `'\windows/unix/mixed'`
      ✓ `'////\\windows\\..\\unix/mixed/'`   --->                `'/unix/mixed/'`  // `path.normalize()` gives `'/\windows\..\unix/mixed/'`
\end{DoxyVerb}


Joining paths can also be a problem\+: \begin{DoxyVerb}`upath.join(paths...)`        --returns-->

      ✓ `'some/nodejs/deep', '../path'`       --->       `'some/nodejs/path'`  // equal to `path.join()`
      ✓ `'some/nodejs\\windows', '../path'`   --->       `'some/nodejs/path'`  // `path.join()` gives `'some/path'`
      ✓ `'some\\windows\\only', '..\\path'`   --->      `'some/windows/path'`  // `path.join()` gives `'some\windows\only/..\path'`
\end{DoxyVerb}


Parsing with {\ttfamily path.\+parse()} should also be consistent across OSes\+:

{\ttfamily upath.\+parse(path)} --returns-\/-\/$>$ \begin{DoxyVerb}    ✓ `'c:\Windows\Directory\somefile.ext'`      ---> `{ root: '', dir: 'c:/Windows/Directory', base: 'somefile.ext', ext: '.ext', name: 'somefile' }`
                              // `path.parse()` gives `'{ root: '', dir: '', base: 'c:\\Windows\\Directory\\somefile.ext', ext: '.ext', name: 'c:\\Windows\\Directory\\somefile' }'`
    ✓ `'/root/of/unix/somefile.ext'`             ---> `{ root: '/', dir: '/root/of/unix', base: 'somefile.ext', ext: '.ext', name: 'somefile' }`  // equal to `path.parse()`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31545}{}\doxysection{Added functions}\label{md_sfcode_node_modules_upath_readme_autotoc_md31545}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31546}{}\doxysubsubsection{$<$tt$>$upath.\+to\+Unix(path)$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31546}
Just converts all \`{}{\ttfamily to}/\`{} and consolidates duplicates, without performing any normalization.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31547}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31547}
\begin{DoxyVerb}`upath.toUnix(path)`        --returns-->

    ✓ `'.//windows\//unix//mixed////'`      --->         `'./windows/unix/mixed/'`
    ✓ `'..///windows\..\\unix/mixed'`       --->      `'../windows/../unix/mixed'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31548}{}\doxysubsubsection{$<$tt$>$upath.\+normalize\+Safe(path)$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31548}
Exactly like {\ttfamily path.\+normalize(path)}, but it keeps the first meaningful {\ttfamily ./}.

Note that the unix {\ttfamily /} is returned everywhere, so windows {\ttfamily \textbackslash{}} is always converted to unix {\ttfamily /}.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31549}{}\doxyparagraph{Examples / specs \& how it differs from vanilla $<$tt$>$path$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31549}
\begin{DoxyVerb}`upath.normalizeSafe(path)`        --returns-->

    ✓ `''`                               --->                          `'.'`  // equal to `path.normalize()`
    ✓ `'.'`                              --->                          `'.'`  // equal to `path.normalize()`
    ✓ `'./'`                             --->                         `'./'`  // equal to `path.normalize()`
    ✓ `'.//'`                            --->                         `'./'`  // equal to `path.normalize()`
    ✓ `'.\\'`                            --->                         `'./'`  // `path.normalize()` gives `'.\'`
    ✓ `'.\\//'`                          --->                         `'./'`  // `path.normalize()` gives `'.\/'`
    ✓ `'./..'`                           --->                         `'..'`  // equal to `path.normalize()`
    ✓ `'.//..'`                          --->                         `'..'`  // equal to `path.normalize()`
    ✓ `'./../'`                          --->                        `'../'`  // equal to `path.normalize()`
    ✓ `'.\\..\\'`                        --->                        `'../'`  // `path.normalize()` gives `'.\..\'`
    ✓ `'./../dep'`                       --->                     `'../dep'`  // equal to `path.normalize()`
    ✓ `'../dep'`                         --->                     `'../dep'`  // equal to `path.normalize()`
    ✓ `'../path/dep'`                    --->                `'../path/dep'`  // equal to `path.normalize()`
    ✓ `'../path/../dep'`                 --->                     `'../dep'`  // equal to `path.normalize()`
    ✓ `'dep'`                            --->                        `'dep'`  // equal to `path.normalize()`
    ✓ `'path//dep'`                      --->                   `'path/dep'`  // equal to `path.normalize()`
    ✓ `'./dep'`                          --->                      `'./dep'`  // `path.normalize()` gives `'dep'`
    ✓ `'./path/dep'`                     --->                 `'./path/dep'`  // `path.normalize()` gives `'path/dep'`
    ✓ `'./path/../dep'`                  --->                      `'./dep'`  // `path.normalize()` gives `'dep'`
    ✓ `'.//windows\\unix/mixed/'`        --->      `'./windows/unix/mixed/'`  // `path.normalize()` gives `'windows\unix/mixed/'`
    ✓ `'..//windows\\unix/mixed'`        --->      `'../windows/unix/mixed'`  // `path.normalize()` gives `'../windows\unix/mixed'`
    ✓ `'windows\\unix/mixed/'`           --->        `'windows/unix/mixed/'`  // `path.normalize()` gives `'windows\unix/mixed/'`
    ✓ `'..//windows\\..\\unix/mixed'`    --->              `'../unix/mixed'`  // `path.normalize()` gives `'../windows\..\unix/mixed'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31550}{}\doxysubsubsection{$<$tt$>$upath.\+normalize\+Trim(path)$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31550}
Exactly like {\ttfamily path.\+normalize\+Safe(path)}, but it trims any useless ending {\ttfamily /}.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31551}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31551}
\begin{DoxyVerb}`upath.normalizeTrim(path)`        --returns-->

    ✓ `'./'`                          --->                         `'.'`  // `upath.normalizeSafe()` gives `'./'`
    ✓ `'./../'`                       --->                        `'..'`  // `upath.normalizeSafe()` gives `'../'`
    ✓ `'./../dep/'`                   --->                    `'../dep'`  // `upath.normalizeSafe()` gives `'../dep/'`
    ✓ `'path//dep\\'`                 --->                  `'path/dep'`  // `upath.normalizeSafe()` gives `'path/dep/'`
    ✓ `'.//windows\\unix/mixed/'`     --->      `'./windows/unix/mixed'`  // `upath.normalizeSafe()` gives `'./windows/unix/mixed/'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31552}{}\doxysubsubsection{$<$tt$>$upath.\+join\+Safe(\mbox{[}path1\mbox{]}\mbox{[}, path2\mbox{]}\mbox{[}, ...\mbox{]})$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31552}
Exactly like {\ttfamily path.\+join()}, but it keeps the first meaningful {\ttfamily ./}.

Note that the unix {\ttfamily /} is returned everywhere, so windows {\ttfamily \textbackslash{}} is always converted to unix {\ttfamily /}.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31553}{}\doxyparagraph{Examples / specs \& how it differs from vanilla $<$tt$>$path$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31553}
\begin{DoxyVerb}`upath.joinSafe(path)`        --returns-->

    ✓ `'some/nodejs/deep', '../path'`                --->           `'some/nodejs/path'`  // equal to `path.join()`
    ✓ `'./some/local/unix/', '../path'`              --->          `'./some/local/path'`  // `path.join()` gives `'some/local/path'`
    ✓ `'./some\\current\\mixed', '..\\path'`         --->        `'./some/current/path'`  // `path.join()` gives `'some\current\mixed/..\path'`
    ✓ `'../some/relative/destination', '..\\path'`   --->      `'../some/relative/path'`  // `path.join()` gives `'../some/relative/destination/..\path'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31554}{}\doxysection{Added functions for $<$em$>$filename extension$<$/em$>$ manipulation.}\label{md_sfcode_node_modules_upath_readme_autotoc_md31554}
{\bfseries{Happy notes\+:}}

In all functions you can\+:


\begin{DoxyItemize}
\item use both {\ttfamily .ext} \& {\ttfamily ext} -\/ the dot {\ttfamily .} on the extension is always adjusted correctly.
\item omit the {\ttfamily ext} param (pass null/undefined/empty string) and the common sense thing will happen.
\item ignore specific extensions from being considered as valid ones (eg {\ttfamily .min}, {\ttfamily .dev} {\ttfamily .a\+Long\+Ext\+Is\+Not\+An\+Ext} etc), hence no trimming or replacement takes place on them.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31555}{}\doxysubsubsection{$<$tt$>$upath.\+add\+Ext(filename, \mbox{[}ext\mbox{]})$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31555}
Adds {\ttfamily .ext} to {\ttfamily filename}, but only if it doesn\textquotesingle{}t already have the exact extension.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31556}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31556}
\begin{DoxyVerb}`upath.addExt(filename, 'js')`     --returns-->

    ✓ `'myfile/addExt'`           --->           `'myfile/addExt.js'`
    ✓ `'myfile/addExt.txt'`       --->       `'myfile/addExt.txt.js'`
    ✓ `'myfile/addExt.js'`        --->           `'myfile/addExt.js'`
    ✓ `'myfile/addExt.min.'`      --->      `'myfile/addExt.min..js'`
\end{DoxyVerb}


It adds nothing if no {\ttfamily ext} param is passed. \begin{DoxyVerb}`upath.addExt(filename)`           --returns-->

      ✓ `'myfile/addExt'`           --->              `'myfile/addExt'`
      ✓ `'myfile/addExt.txt'`       --->          `'myfile/addExt.txt'`
      ✓ `'myfile/addExt.js'`        --->           `'myfile/addExt.js'`
      ✓ `'myfile/addExt.min.'`      --->         `'myfile/addExt.min.'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31557}{}\doxysubsubsection{$<$tt$>$upath.\+trim\+Ext(filename, \mbox{[}ignore\+Exts\mbox{]}, \mbox{[}max\+Size=7\mbox{]})$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31557}
Trims a filename\textquotesingle{}s extension.


\begin{DoxyItemize}
\item Extensions are considered to be up to {\ttfamily max\+Size} chars long, counting the dot (defaults to 7).
\item An {\ttfamily Array} of {\ttfamily ignore\+Exts} (eg `\mbox{[}'.min\textquotesingle{}\mbox{]}\`{}) prevents these from being considered as extension, thus are not trimmed.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31558}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31558}
\begin{DoxyVerb}`upath.trimExt(filename)`          --returns-->

    ✓ `'my/trimedExt.txt'`             --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt'`                 --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt.min'`             --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt.min.js'`          --->             `'my/trimedExt.min'`
    ✓ `'../my/trimedExt.longExt'`      --->      `'../my/trimedExt.longExt'`
\end{DoxyVerb}


It is ignoring {\ttfamily .min} \& {\ttfamily .dev} as extensions, and considers exts with up to 8 chars. \begin{DoxyVerb}`upath.trimExt(filename, ['min', '.dev'], 8)`          --returns-->

      ✓ `'my/trimedExt.txt'`              --->                  `'my/trimedExt'`
      ✓ `'my/trimedExt.min'`              --->              `'my/trimedExt.min'`
      ✓ `'my/trimedExt.dev'`              --->              `'my/trimedExt.dev'`
      ✓ `'../my/trimedExt.longExt'`       --->               `'../my/trimedExt'`
      ✓ `'../my/trimedExt.longRExt'`      --->      `'../my/trimedExt.longRExt'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31559}{}\doxysubsubsection{$<$tt$>$upath.\+remove\+Ext(filename, ext)$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31559}
Removes the specific {\ttfamily ext} extension from filename, if it has it. Otherwise it leaves it as is. As in all upath functions, it be {\ttfamily .ext} or {\ttfamily ext}.\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31560}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31560}
\begin{DoxyVerb}`upath.removeExt(filename, '.js')`          --returns-->

    ✓ `'removedExt.js'`          --->          `'removedExt'`
    ✓ `'removedExt.txt.js'`      --->      `'removedExt.txt'`
    ✓ `'notRemoved.txt'`         --->      `'notRemoved.txt'`
\end{DoxyVerb}
 It does not care about the length of exts. \begin{DoxyVerb}`upath.removeExt(filename, '.longExt')`          --returns-->

    ✓ `'removedExt.longExt'`          --->          `'removedExt'`
    ✓ `'removedExt.txt.longExt'`      --->      `'removedExt.txt'`
    ✓ `'notRemoved.txt'`              --->      `'notRemoved.txt'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31561}{}\doxysubsubsection{$<$tt$>$upath.\+change\+Ext(filename, \mbox{[}ext\mbox{]}, \mbox{[}ignore\+Exts\mbox{]}, \mbox{[}max\+Size=7\mbox{]})$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31561}
Changes a filename\textquotesingle{}s extension to {\ttfamily ext}. If it has no (valid) extension, it adds it.


\begin{DoxyItemize}
\item Valid extensions are considered to be up to {\ttfamily max\+Size} chars long, counting the dot (defaults to 7).
\item An {\ttfamily Array} of {\ttfamily ignore\+Exts} (eg `\mbox{[}'.min\textquotesingle{}\mbox{]}\`{}) prevents these from being considered as extension, thus are not changed -\/ the new extension is added instead.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31562}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31562}
\begin{DoxyVerb}`upath.changeExt(filename, '.js')`  --returns-->

    ✓ `'my/module.min'`            --->                `'my/module.js'`
    ✓ `'my/module.coffee'`         --->                `'my/module.js'`
    ✓ `'my/module'`                --->                `'my/module.js'`
    ✓ `'file/withDot.'`            --->             `'file/withDot.js'`
    ✓ `'file/change.longExt'`      --->      `'file/change.longExt.js'`
\end{DoxyVerb}


If no {\ttfamily ext} param is given, it trims the current extension (if any). \begin{DoxyVerb}`upath.changeExt(filename)`        --returns-->

      ✓ `'my/module.min'`            --->                   `'my/module'`
      ✓ `'my/module.coffee'`         --->                   `'my/module'`
      ✓ `'my/module'`                --->                   `'my/module'`
      ✓ `'file/withDot.'`            --->                `'file/withDot'`
      ✓ `'file/change.longExt'`      --->         `'file/change.longExt'`
\end{DoxyVerb}


It is ignoring {\ttfamily .min} \& {\ttfamily .dev} as extensions, and considers exts with up to 8 chars. \begin{DoxyVerb}`upath.changeExt(filename, 'js', ['min', '.dev'], 8)`        --returns-->

      ✓ `'my/module.coffee'`          --->                 `'my/module.js'`
      ✓ `'file/notValidExt.min'`      --->      `'file/notValidExt.min.js'`
      ✓ `'file/notValidExt.dev'`      --->      `'file/notValidExt.dev.js'`
      ✓ `'file/change.longExt'`       --->               `'file/change.js'`
      ✓ `'file/change.longRExt'`      --->      `'file/change.longRExt.js'`
\end{DoxyVerb}
\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31563}{}\doxysubsubsection{$<$tt$>$upath.\+default\+Ext(filename, \mbox{[}ext\mbox{]}, \mbox{[}ignore\+Exts\mbox{]}, \mbox{[}max\+Size=7\mbox{]})$<$/tt$>$}\label{md_sfcode_node_modules_upath_readme_autotoc_md31563}
Adds {\ttfamily .ext} to {\ttfamily filename}, only if it doesn\textquotesingle{}t already have {\itshape any} {\itshape old} extension.


\begin{DoxyItemize}
\item (Old) extensions are considered to be up to {\ttfamily max\+Size} chars long, counting the dot (defaults to 7).
\item An {\ttfamily Array} of {\ttfamily ignore\+Exts} (eg `\mbox{[}'.min\textquotesingle{}\mbox{]}{\ttfamily ) will force adding default}.ext\`{} even if one of these is present.
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_upath_readme_autotoc_md31564}{}\doxyparagraph{Examples / specs}\label{md_sfcode_node_modules_upath_readme_autotoc_md31564}
\begin{DoxyVerb}`upath.defaultExt(filename, 'js')`   --returns-->

    ✓ `'fileWith/defaultExt'`              --->              `'fileWith/defaultExt.js'`
    ✓ `'fileWith/defaultExt.js'`           --->              `'fileWith/defaultExt.js'`
    ✓ `'fileWith/defaultExt.min'`          --->             `'fileWith/defaultExt.min'`
    ✓ `'fileWith/defaultExt.longExt'`      --->      `'fileWith/defaultExt.longExt.js'`
\end{DoxyVerb}


If no {\ttfamily ext} param is passed, it leaves filename intact. \begin{DoxyVerb}`upath.defaultExt(filename)`       --returns-->

      ✓ `'fileWith/defaultExt'`              --->                 `'fileWith/defaultExt'`
      ✓ `'fileWith/defaultExt.js'`           --->              `'fileWith/defaultExt.js'`
      ✓ `'fileWith/defaultExt.min'`          --->             `'fileWith/defaultExt.min'`
      ✓ `'fileWith/defaultExt.longExt'`      --->         `'fileWith/defaultExt.longExt'`
\end{DoxyVerb}


It is ignoring {\ttfamily .min} \& {\ttfamily .dev} as extensions, and considers exts with up to 8 chars. \begin{DoxyVerb}`upath.defaultExt(filename, 'js', ['min', '.dev'], 8)` --returns-->

      ✓ `'fileWith/defaultExt'`               --->               `'fileWith/defaultExt.js'`
      ✓ `'fileWith/defaultExt.min'`           --->           `'fileWith/defaultExt.min.js'`
      ✓ `'fileWith/defaultExt.dev'`           --->           `'fileWith/defaultExt.dev.js'`
      ✓ `'fileWith/defaultExt.longExt'`       --->          `'fileWith/defaultExt.longExt'`
      ✓ `'fileWith/defaultExt.longRext'`      --->      `'fileWith/defaultExt.longRext.js'`
\end{DoxyVerb}


Copyright(c) 2014-\/2019 Angelos Pikoulas (\href{mailto:agelos.pikoulas@gmail.com}{\texttt{ agelos.\+pikoulas@gmail.\+com}})

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \char`\"{}\+Software\char`\"{}), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions\+:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED \char`\"{}\+AS IS\char`\"{}, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 