1 files changed, 0 insertions, 204 deletions
diff --git a/node_modules/dir-compare/src/index.js b/node_modules/dir-compare/src/index.js
deleted file mode 100644
index fb1b6b8..0000000
--- a/node_modules/dir-compare/src/index.js
+++ /dev/null
@@ -1,204 +0,0 @@
-var util = require('util')
-var pathUtils = require('path')
-var fs = require('fs')
-var compareSyncInternal = require('./compareSync')
-var compareAsyncInternal = require('./compareAsync')
-var defaultResultBuilderCallback = require('./resultBuilder/defaultResultBuilderCallback')
-var defaultFileCompare = require('./fileCompareHandler/defaultFileCompare')
-var lineBasedFileCompare = require('./fileCompareHandler/lineBasedFileCompare')
-var defaultNameCompare = require('./nameCompare/defaultNameCompare')
-var entryBuilder = require('./entry/entryBuilder')
-var statsLifecycle = require('./statistics/statisticsLifecycle')
-var loopDetector = require('./symlink/loopDetector')
-
-var ROOT_PATH = pathUtils.sep
-
-var compareSync = function (path1, path2, options) {
-    'use strict'
-    // realpathSync() is necessary for loop detection to work properly
-    var absolutePath1 = pathUtils.normalize(pathUtils.resolve(fs.realpathSync(path1)))
-    var absolutePath2 = pathUtils.normalize(pathUtils.resolve(fs.realpathSync(path2)))
-    var diffSet
-    options = prepareOptions(options)
-    if (!options.noDiffSet) {
-        diffSet = []
-    }
-    var statistics = statsLifecycle.initStats(options)
-    compareSyncInternal(
-        entryBuilder.buildEntry(absolutePath1, path1, pathUtils.basename(absolutePath1)),
-        entryBuilder.buildEntry(absolutePath2, path2, pathUtils.basename(absolutePath2)),
-        0, ROOT_PATH, options, statistics, diffSet, loopDetector.initSymlinkCache())
-    statsLifecycle.completeStatistics(statistics, options)
-    statistics.diffSet = diffSet
-
-    return statistics
-}
-
-var wrapper = {
-    realPath: function(path, options) {
-        return new Promise(function (resolve, reject) {
-            fs.realpath(path, options, function(err, resolvedPath) {
-                if(err){
-                    reject(err)
-                } else {
-                    resolve(resolvedPath)
-                }
-            })
-        })
-    }
-}
-
-var compareAsync = function (path1, path2, options) {
-    'use strict'
-    var absolutePath1, absolutePath2
-    return Promise.resolve()
-        .then(function () {
-            return Promise.all([wrapper.realPath(path1), wrapper.realPath(path2)])
-        })
-        .then(function (realPaths) {
-            var realPath1 = realPaths[0]
-            var realPath2 = realPaths[1]
-            // realpath() is necessary for loop detection to work properly
-            absolutePath1 = pathUtils.normalize(pathUtils.resolve(realPath1))
-            absolutePath2 = pathUtils.normalize(pathUtils.resolve(realPath2))
-        })
-        .then(function () {
-            options = prepareOptions(options)
-            var asyncDiffSet
-            if (!options.noDiffSet) {
-                asyncDiffSet = []
-            }
-            var statistics = statsLifecycle.initStats(options)
-            return compareAsyncInternal(
-                entryBuilder.buildEntry(absolutePath1, path1, pathUtils.basename(path1)),
-                entryBuilder.buildEntry(absolutePath2, path2, pathUtils.basename(path2)),
-                0, ROOT_PATH, options, statistics, asyncDiffSet, loopDetector.initSymlinkCache()).then(
-                    function () {
-                        statsLifecycle.completeStatistics(statistics, options)
-                        if (!options.noDiffSet) {
-                            var diffSet = []
-                            rebuildAsyncDiffSet(statistics, asyncDiffSet, diffSet)
-                            statistics.diffSet = diffSet
-                        }
-                        return statistics
-                    })
-        })
-}
-
-var prepareOptions = function (options) {
-    options = options || {}
-    var clone = JSON.parse(JSON.stringify(options))
-    clone.resultBuilder = options.resultBuilder
-    clone.compareFileSync = options.compareFileSync
-    clone.compareFileAsync = options.compareFileAsync
-    clone.compareNameHandler = options.compareNameHandler
-    if (!clone.resultBuilder) {
-        clone.resultBuilder = defaultResultBuilderCallback
-    }
-    if (!clone.compareFileSync) {
-        clone.compareFileSync = defaultFileCompare.compareSync
-    }
-    if (!clone.compareFileAsync) {
-        clone.compareFileAsync = defaultFileCompare.compareAsync
-    }
-    if(!clone.compareNameHandler) {
-        clone.compareNameHandler = defaultNameCompare
-    }
-    clone.dateTolerance = clone.dateTolerance || 1000
-    clone.dateTolerance = Number(clone.dateTolerance)
-    if (isNaN(clone.dateTolerance)) {
-        throw new Error('Date tolerance is not a number')
-    }
-    return clone
-}
-
-
-// Async diffsets are kept into recursive structures.
-// This method transforms them into one dimensional arrays.
-var rebuildAsyncDiffSet = function (statistics, asyncDiffSet, diffSet) {
-    asyncDiffSet.forEach(function (rawDiff) {
-        if (!Array.isArray(rawDiff)) {
-            diffSet.push(rawDiff)
-        } else {
-            rebuildAsyncDiffSet(statistics, rawDiff, diffSet)
-        }
-    })
-}
-
-
-/**
- * Options:
- * compareSize: true/false - Compares files by size. Defaults to 'false'.
- * compareDate: true/false - Compares files by date of modification (stat.mtime). Defaults to 'false'.
- * dateTolerance: milliseconds - Two files are considered to have the same date if the difference between their modification dates fits within date tolerance. Defaults to 1000 ms.
- * compareContent: true/false - Compares files by content. Defaults to 'false'.
- * compareSymlink: true/false - Compares entries by symlink. Defaults to 'false'.
- * skipSubdirs: true/false - Skips sub directories. Defaults to 'false'.
- * skipSymlinks: true/false - Skips symbolic links. Defaults to 'false'.
- * ignoreCase: true/false - Ignores case when comparing names. Defaults to 'false'.
- * noDiffSet: true/false - Toggles presence of diffSet in output. If true, only statistics are provided. Use this when comparing large number of files to avoid out of memory situations. Defaults to 'false'.
- * includeFilter: File name filter. Comma separated [minimatch](https://www.npmjs.com/package/minimatch) patterns.
- * excludeFilter: File/directory name exclude filter. Comma separated [minimatch](https://www.npmjs.com/package/minimatch) patterns.
- * resultBuilder: Callback for constructing result.
- * 	function (entry1, entry2, state, level, relativePath, options, statistics, diffSet). Called for each compared entry pair. Updates 'statistics' and 'diffSet'.
- * compareFileSync, compareFileAsync: Callbacks for file comparison. 
- * compareNameHandler: Callback for name comparison
- *
- * Result:
- * same: true if directories are identical
- * distinct: number of distinct entries
- * equal: number of equal entries
- * left: number of entries only in path1
- * right: number of entries only in path2
- * differences: total number of differences (distinct+left+right)
- * total: total number of entries (differences+equal)
- * distinctFiles: number of distinct files
- * equalFiles: number of equal files
- * leftFiles: number of files only in path1
- * rightFiles: number of files only in path2
- * differencesFiles: total number of different files (distinctFiles+leftFiles+rightFiles)
- * totalFiles: total number of files (differencesFiles+equalFiles)
- * distinctDirs: number of distinct directories
- * equalDirs: number of equal directories
- * leftDirs: number of directories only in path1
- * rightDirs: number of directories only in path2
- * differencesDirs: total number of different directories (distinctDirs+leftDirs+rightDirs)
- * totalDirs: total number of directories (differencesDirs+equalDirs)
- * brokenLinks:
- *     leftBrokenLinks: number of broken links only in path1
- *     rightBrokenLinks: number of broken links only in path2
- *     distinctBrokenLinks: number of broken links with same name appearing in both path1 and path2
- *     totalBrokenLinks: total number of broken links (leftBrokenLinks+rightBrokenLinks+distinctBrokenLinks)
- * symlinks: Statistics available if 'compareSymlink' options is used
- *     distinctSymlinks: number of distinct links
- *     equalSymlinks: number of equal links
- *     leftSymlinks: number of links only in path1
- *     rightSymlinks: number of links only in path2
- *     differencesSymlinks: total number of different links (distinctSymlinks+leftSymlinks+rightSymlinks)
- *     totalSymlinks: total number of links (differencesSymlinks+equalSymlinks)
- * diffSet - List of changes (present if Options.noDiffSet is false)
- *     path1: absolute path not including file/directory name,
- *     path2: absolute path not including file/directory name,
- *     relativePath: common path relative to root,
- *     name1: file/directory name
- *     name2: file/directory name
- *     state: one of equal, left, right, distinct,
- *     type1: one of missing, file, directory, broken-link
- *     type2: one of missing, file, directory, broken-link
- *     size1: file size
- *     size2: file size
- *     date1: modification date (stat.mtime)
- *     date2: modification date (stat.mtime)
- *     level: depth
- *     reason: Provides reason when two identically named entries are distinct
- *             Not available if entries are equal
- *             One of "different-size", "different-date", "different-content", "broken-link", "different-symlink"
- */
-module.exports = {
-    compareSync: compareSync,
-    compare: compareAsync,
-    fileCompareHandlers: {
-        defaultFileCompare: defaultFileCompare,
-        lineBasedFileCompare: lineBasedFileCompare
-    }
-}