node_modules/watchpack-chokidar2/node_modules/chokidar/lib/fsevents-handler.js - nifi-fds - Git at Google

 'use strict';

 var fs = require('fs');
 var sysPath = require('path');
 var readdirp = require('readdirp');
 var fsevents;
 try { fsevents = require('fsevents'); } catch (error) {
   if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error)
 }

 // fsevents instance helper functions

 // object to hold per-process fsevents instances
 // (may be shared across chokidar FSWatcher instances)
 var FSEventsWatchers = Object.create(null);

 // Threshold of duplicate path prefixes at which to start
 // consolidating going forward
 var consolidateThreshhold = 10;

 // Private function: Instantiates the fsevents interface

 // * path       - string, path to be watched
 // * callback   - function, called when fsevents is bound and ready

 // Returns new fsevents instance
 function createFSEventsInstance(path, callback) {
   return (new fsevents(path)).on('fsevent', callback).start();
 }

 // Private function: Instantiates the fsevents interface or binds listeners
 // to an existing one covering the same file tree

 // * path       - string, path to be watched
 // * realPath   - string, real path (in case of symlinks)
 // * listener   - function, called when fsevents emits events
 // * rawEmitter - function, passes data to listeners of the 'raw' event

 // Returns close function
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
   var watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
   var watchContainer;
   var parentPath = sysPath.dirname(watchPath);

   // If we've accumulated a substantial number of paths that
   // could have been consolidated by watching one directory
   // above the current one, create a watcher on the parent
   // path instead, so that we do consolidate going forward.
   if (couldConsolidate(parentPath)) {
     watchPath = parentPath;
   }

   var resolvedPath = sysPath.resolve(path);
   var hasSymlink = resolvedPath !== realPath;
   function filteredListener(fullPath, flags, info) {
     if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
     if (
       fullPath === resolvedPath ||
       !fullPath.indexOf(resolvedPath + sysPath.sep)
     ) listener(fullPath, flags, info);
   }

   // check if there is already a watcher on a parent path
   // modifies `watchPath` to the parent path when it finds a match
   function watchedParent() {
     return Object.keys(FSEventsWatchers).some(function(watchedPath) {
       // condition is met when indexOf returns 0
       if (!realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep)) {
         watchPath = watchedPath;
         return true;
       }
     });
   }

   if (watchPath in FSEventsWatchers || watchedParent()) {
     watchContainer = FSEventsWatchers[watchPath];
     watchContainer.listeners.push(filteredListener);
   } else {
     watchContainer = FSEventsWatchers[watchPath] = {
       listeners: [filteredListener],
       rawEmitters: [rawEmitter],
       watcher: createFSEventsInstance(watchPath, function(fullPath, flags) {
         var info = fsevents.getInfo(fullPath, flags);
         watchContainer.listeners.forEach(function(listener) {
           listener(fullPath, flags, info);
         });
         watchContainer.rawEmitters.forEach(function(emitter) {
           emitter(info.event, fullPath, info);
         });
       })
     };
   }
   var listenerIndex = watchContainer.listeners.length - 1;

   // removes this instance's listeners and closes the underlying fsevents
   // instance if there are no more listeners left
   return function close() {
     delete watchContainer.listeners[listenerIndex];
     delete watchContainer.rawEmitters[listenerIndex];
     if (!Object.keys(watchContainer.listeners).length) {
       watchContainer.watcher.stop();
       delete FSEventsWatchers[watchPath];
     }
   };
 }

 // Decide whether or not we should start a new higher-level
 // parent watcher
 function couldConsolidate(path) {
   var keys = Object.keys(FSEventsWatchers);
   var count = 0;

   for (var i = 0, len = keys.length; i < len; ++i) {
     var watchPath = keys[i];
     if (watchPath.indexOf(path) === 0) {
       count++;
       if (count >= consolidateThreshhold) {
         return true;
       }
     }
   }

   return false;
 }

 function isConstructor(obj) {
   return obj.prototype !== undefined && obj.prototype.constructor !== undefined;
 }

 // returns boolean indicating whether fsevents can be used
 function canUse() {
   return fsevents && Object.keys(FSEventsWatchers).length < 128 && isConstructor(fsevents);
 }

 // determines subdirectory traversal levels from root to path
 function depth(path, root) {
   var i = 0;
   while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
   return i;
 }

 // fake constructor for attaching fsevents-specific prototype methods that
 // will be copied to FSWatcher's prototype
 function FsEventsHandler() {}

 // Private method: Handle symlinks encountered during directory scan

 // * watchPath  - string, file/dir path to be watched with fsevents
 // * realPath   - string, real path (in case of symlinks)
 // * transform  - function, path transformer
 // * globFilter - function, path filter in case a glob pattern was provided

 // Returns close function for the watcher instance
 FsEventsHandler.prototype._watchWithFsEvents =
 function(watchPath, realPath, transform, globFilter) {
   if (this._isIgnored(watchPath)) return;
   var watchCallback = function(fullPath, flags, info) {
     if (
       this.options.depth !== undefined &&
       depth(fullPath, realPath) > this.options.depth
     ) return;
     var path = transform(sysPath.join(
       watchPath, sysPath.relative(watchPath, fullPath)
     ));
     if (globFilter && !globFilter(path)) return;
     // ensure directories are tracked
     var parent = sysPath.dirname(path);
     var item = sysPath.basename(path);
     var watchedDir = this._getWatchedDir(
       info.type === 'directory' ? path : parent
     );
     var checkIgnored = function(stats) {
       if (this._isIgnored(path, stats)) {
         this._ignoredPaths[path] = true;
         if (stats && stats.isDirectory()) {
           this._ignoredPaths[path + '/**/*'] = true;
         }
         return true;
       } else {
         delete this._ignoredPaths[path];
         delete this._ignoredPaths[path + '/**/*'];
       }
     }.bind(this);

     var handleEvent = function(event) {
       if (checkIgnored()) return;

       if (event === 'unlink') {
         // suppress unlink events on never before seen files
         if (info.type === 'directory' || watchedDir.has(item)) {
           this._remove(parent, item);
         }
       } else {
         if (event === 'add') {
           // track new directories
           if (info.type === 'directory') this._getWatchedDir(path);

           if (info.type === 'symlink' && this.options.followSymlinks) {
             // push symlinks back to the top of the stack to get handled
             var curDepth = this.options.depth === undefined ?
               undefined : depth(fullPath, realPath) + 1;
             return this._addToFsEvents(path, false, true, curDepth);
           } else {
             // track new paths
             // (other than symlinks being followed, which will be tracked soon)
             this._getWatchedDir(parent).add(item);
           }
         }
         var eventName = info.type === 'directory' ? event + 'Dir' : event;
         this._emit(eventName, path);
         if (eventName === 'addDir') this._addToFsEvents(path, false, true);
       }
     }.bind(this);

     function addOrChange() {
       handleEvent(watchedDir.has(item) ? 'change' : 'add');
     }
     function checkFd() {
       fs.open(path, 'r', function(error, fd) {
         if (error) {
           error.code !== 'EACCES' ?
             handleEvent('unlink') : addOrChange();
         } else {
           fs.close(fd, function(err) {
             err && err.code !== 'EACCES' ?
               handleEvent('unlink') : addOrChange();
           });
         }
       });
     }
     // correct for wrong events emitted
     var wrongEventFlags = [
       69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
     ];
     if (wrongEventFlags.indexOf(flags) !== -1 || info.event === 'unknown') {
       if (typeof this.options.ignored === 'function') {
         fs.stat(path, function(error, stats) {
           if (checkIgnored(stats)) return;
           stats ? addOrChange() : handleEvent('unlink');
         });
       } else {
         checkFd();
       }
     } else {
       switch (info.event) {
       case 'created':
       case 'modified':
         return addOrChange();
       case 'deleted':
       case 'moved':
         return checkFd();
       }
     }
   }.bind(this);

   var closer = setFSEventsListener(
     watchPath,
     realPath,
     watchCallback,
     this.emit.bind(this, 'raw')
   );

   this._emitReady();
   return closer;
 };

 // Private method: Handle symlinks encountered during directory scan

 // * linkPath   - string, path to symlink
 // * fullPath   - string, absolute path to the symlink
 // * transform  - function, pre-existing path transformer
 // * curDepth   - int, level of subdirectories traversed to where symlink is

 // Returns nothing
 FsEventsHandler.prototype._handleFsEventsSymlink =
 function(linkPath, fullPath, transform, curDepth) {
   // don't follow the same symlink more than once
   if (this._symlinkPaths[fullPath]) return;
   else this._symlinkPaths[fullPath] = true;

   this._readyCount++;

   fs.realpath(linkPath, function(error, linkTarget) {
     if (this._handleError(error) || this._isIgnored(linkTarget)) {
       return this._emitReady();
     }

     this._readyCount++;

     // add the linkTarget for watching with a wrapper for transform
     // that causes emitted paths to incorporate the link's path
     this._addToFsEvents(linkTarget || linkPath, function(path) {
       var dotSlash = '.' + sysPath.sep;
       var aliasedPath = linkPath;
       if (linkTarget && linkTarget !== dotSlash) {
         aliasedPath = path.replace(linkTarget, linkPath);
       } else if (path !== dotSlash) {
         aliasedPath = sysPath.join(linkPath, path);
       }
       return transform(aliasedPath);
     }, false, curDepth);
   }.bind(this));
 };

 // Private method: Handle added path with fsevents

 // * path       - string, file/directory path or glob pattern
 // * transform  - function, converts working path to what the user expects
 // * forceAdd   - boolean, ensure add is emitted
 // * priorDepth - int, level of subdirectories already traversed

 // Returns nothing
 FsEventsHandler.prototype._addToFsEvents =
 function(path, transform, forceAdd, priorDepth) {

   // applies transform if provided, otherwise returns same value
   var processPath = typeof transform === 'function' ?
     transform : function(val) { return val; };

   var emitAdd = function(newPath, stats) {
     var pp = processPath(newPath);
     var isDir = stats.isDirectory();
     var dirObj = this._getWatchedDir(sysPath.dirname(pp));
     var base = sysPath.basename(pp);

     // ensure empty dirs get tracked
     if (isDir) this._getWatchedDir(pp);

     if (dirObj.has(base)) return;
     dirObj.add(base);

     if (!this.options.ignoreInitial || forceAdd === true) {
       this._emit(isDir ? 'addDir' : 'add', pp, stats);
     }
   }.bind(this);

   var wh = this._getWatchHelpers(path);

   // evaluate what is at the path we're being asked to watch
   fs[wh.statMethod](wh.watchPath, function(error, stats) {
     if (this._handleError(error) || this._isIgnored(wh.watchPath, stats)) {
       this._emitReady();
       return this._emitReady();
     }

     if (stats.isDirectory()) {
       // emit addDir unless this is a glob parent
       if (!wh.globFilter) emitAdd(processPath(path), stats);

       // don't recurse further if it would exceed depth setting
       if (priorDepth && priorDepth > this.options.depth) return;

       // scan the contents of the dir
       readdirp({
         root: wh.watchPath,
         entryType: 'all',
         fileFilter: wh.filterPath,
         directoryFilter: wh.filterDir,
         lstat: true,
         depth: this.options.depth - (priorDepth || 0)
       }).on('data', function(entry) {
         // need to check filterPath on dirs b/c filterDir is less restrictive
         if (entry.stat.isDirectory() && !wh.filterPath(entry)) return;

         var joinedPath = sysPath.join(wh.watchPath, entry.path);
         var fullPath = entry.fullPath;

         if (wh.followSymlinks && entry.stat.isSymbolicLink()) {
           // preserve the current depth here since it can't be derived from
           // real paths past the symlink
           var curDepth = this.options.depth === undefined ?
             undefined : depth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;

           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
           emitAdd(joinedPath, entry.stat);
         }
       }.bind(this)).on('error', function() {
         // Ignore readdirp errors
       }).on('end', this._emitReady);
     } else {
       emitAdd(wh.watchPath, stats);
       this._emitReady();
     }
   }.bind(this));

   if (this.options.persistent && forceAdd !== true) {
     var initWatch = function(error, realPath) {
       if (this.closed) return;
       var closer = this._watchWithFsEvents(
         wh.watchPath,
         sysPath.resolve(realPath || wh.watchPath),
         processPath,
         wh.globFilter
       );
       if (closer) {
         this._closers[path] = this._closers[path] || [];
         this._closers[path].push(closer);
       }
     }.bind(this);

     if (typeof transform === 'function') {
       // realpath has already been resolved
       initWatch();
     } else {
       fs.realpath(wh.watchPath, initWatch);
     }
   }
 };

 module.exports = FsEventsHandler;
 module.exports.canUse = canUse;
	'use strict';

	var fs = require('fs');
	var sysPath = require('path');
	var readdirp = require('readdirp');
	var fsevents;
	try { fsevents = require('fsevents'); } catch (error) {
	if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error)
	}

	// fsevents instance helper functions

	// object to hold per-process fsevents instances
	// (may be shared across chokidar FSWatcher instances)
	var FSEventsWatchers = Object.create(null);

	// Threshold of duplicate path prefixes at which to start
	// consolidating going forward
	var consolidateThreshhold = 10;

	// Private function: Instantiates the fsevents interface

	// * path - string, path to be watched
	// * callback - function, called when fsevents is bound and ready

	// Returns new fsevents instance
	function createFSEventsInstance(path, callback) {
	return (new fsevents(path)).on('fsevent', callback).start();
	}

	// Private function: Instantiates the fsevents interface or binds listeners
	// to an existing one covering the same file tree

	// * path - string, path to be watched
	// * realPath - string, real path (in case of symlinks)
	// * listener - function, called when fsevents emits events
	// * rawEmitter - function, passes data to listeners of the 'raw' event

	// Returns close function
	function setFSEventsListener(path, realPath, listener, rawEmitter) {
	var watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
	var watchContainer;
	var parentPath = sysPath.dirname(watchPath);

	// If we've accumulated a substantial number of paths that
	// could have been consolidated by watching one directory
	// above the current one, create a watcher on the parent
	// path instead, so that we do consolidate going forward.
	if (couldConsolidate(parentPath)) {
	watchPath = parentPath;
	}

	var resolvedPath = sysPath.resolve(path);
	var hasSymlink = resolvedPath !== realPath;
	function filteredListener(fullPath, flags, info) {
	if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
	if (
	fullPath === resolvedPath \|\|
	!fullPath.indexOf(resolvedPath + sysPath.sep)
	) listener(fullPath, flags, info);
	}

	// check if there is already a watcher on a parent path
	// modifies `watchPath` to the parent path when it finds a match
	function watchedParent() {
	return Object.keys(FSEventsWatchers).some(function(watchedPath) {
	// condition is met when indexOf returns 0
	if (!realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep)) {
	watchPath = watchedPath;
	return true;
	}
	});
	}

	if (watchPath in FSEventsWatchers \|\| watchedParent()) {
	watchContainer = FSEventsWatchers[watchPath];
	watchContainer.listeners.push(filteredListener);
	} else {
	watchContainer = FSEventsWatchers[watchPath] = {
	listeners: [filteredListener],
	rawEmitters: [rawEmitter],
	watcher: createFSEventsInstance(watchPath, function(fullPath, flags) {
	var info = fsevents.getInfo(fullPath, flags);
	watchContainer.listeners.forEach(function(listener) {
	listener(fullPath, flags, info);
	});
	watchContainer.rawEmitters.forEach(function(emitter) {
	emitter(info.event, fullPath, info);
	});
	})
	};
	}
	var listenerIndex = watchContainer.listeners.length - 1;

	// removes this instance's listeners and closes the underlying fsevents
	// instance if there are no more listeners left
	return function close() {
	delete watchContainer.listeners[listenerIndex];
	delete watchContainer.rawEmitters[listenerIndex];
	if (!Object.keys(watchContainer.listeners).length) {
	watchContainer.watcher.stop();
	delete FSEventsWatchers[watchPath];
	}
	};
	}

	// Decide whether or not we should start a new higher-level
	// parent watcher
	function couldConsolidate(path) {
	var keys = Object.keys(FSEventsWatchers);
	var count = 0;

	for (var i = 0, len = keys.length; i < len; ++i) {
	var watchPath = keys[i];
	if (watchPath.indexOf(path) === 0) {
	count++;
	if (count >= consolidateThreshhold) {
	return true;
	}
	}
	}

	return false;
	}

	function isConstructor(obj) {
	return obj.prototype !== undefined && obj.prototype.constructor !== undefined;
	}

	// returns boolean indicating whether fsevents can be used
	function canUse() {
	return fsevents && Object.keys(FSEventsWatchers).length < 128 && isConstructor(fsevents);
	}

	// determines subdirectory traversal levels from root to path
	function depth(path, root) {
	var i = 0;
	while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
	return i;
	}

	// fake constructor for attaching fsevents-specific prototype methods that
	// will be copied to FSWatcher's prototype
	function FsEventsHandler() {}

	// Private method: Handle symlinks encountered during directory scan

	// * watchPath - string, file/dir path to be watched with fsevents
	// * realPath - string, real path (in case of symlinks)
	// * transform - function, path transformer
	// * globFilter - function, path filter in case a glob pattern was provided

	// Returns close function for the watcher instance
	FsEventsHandler.prototype._watchWithFsEvents =
	function(watchPath, realPath, transform, globFilter) {
	if (this._isIgnored(watchPath)) return;
	var watchCallback = function(fullPath, flags, info) {
	if (
	this.options.depth !== undefined &&
	depth(fullPath, realPath) > this.options.depth
	) return;
	var path = transform(sysPath.join(
	watchPath, sysPath.relative(watchPath, fullPath)
	));
	if (globFilter && !globFilter(path)) return;
	// ensure directories are tracked
	var parent = sysPath.dirname(path);
	var item = sysPath.basename(path);
	var watchedDir = this._getWatchedDir(
	info.type === 'directory' ? path : parent
	);
	var checkIgnored = function(stats) {
	if (this._isIgnored(path, stats)) {
	this._ignoredPaths[path] = true;
	if (stats && stats.isDirectory()) {
	this._ignoredPaths[path + '/*/'] = true;
	}
	return true;
	} else {
	delete this._ignoredPaths[path];
	delete this._ignoredPaths[path + '/*/'];
	}
	}.bind(this);

	var handleEvent = function(event) {
	if (checkIgnored()) return;

	if (event === 'unlink') {
	// suppress unlink events on never before seen files
	if (info.type === 'directory' \|\| watchedDir.has(item)) {
	this._remove(parent, item);
	}
	} else {
	if (event === 'add') {
	// track new directories
	if (info.type === 'directory') this._getWatchedDir(path);

	if (info.type === 'symlink' && this.options.followSymlinks) {
	// push symlinks back to the top of the stack to get handled
	var curDepth = this.options.depth === undefined ?
	undefined : depth(fullPath, realPath) + 1;
	return this._addToFsEvents(path, false, true, curDepth);
	} else {
	// track new paths
	// (other than symlinks being followed, which will be tracked soon)
	this._getWatchedDir(parent).add(item);
	}
	}
	var eventName = info.type === 'directory' ? event + 'Dir' : event;
	this._emit(eventName, path);
	if (eventName === 'addDir') this._addToFsEvents(path, false, true);
	}
	}.bind(this);

	function addOrChange() {
	handleEvent(watchedDir.has(item) ? 'change' : 'add');
	}
	function checkFd() {
	fs.open(path, 'r', function(error, fd) {
	if (error) {
	error.code !== 'EACCES' ?
	handleEvent('unlink') : addOrChange();
	} else {
	fs.close(fd, function(err) {
	err && err.code !== 'EACCES' ?
	handleEvent('unlink') : addOrChange();
	});
	}
	});
	}
	// correct for wrong events emitted
	var wrongEventFlags = [
	69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
	];
	if (wrongEventFlags.indexOf(flags) !== -1 \|\| info.event === 'unknown') {
	if (typeof this.options.ignored === 'function') {
	fs.stat(path, function(error, stats) {
	if (checkIgnored(stats)) return;
	stats ? addOrChange() : handleEvent('unlink');
	});
	} else {
	checkFd();
	}
	} else {
	switch (info.event) {
	case 'created':
	case 'modified':
	return addOrChange();
	case 'deleted':
	case 'moved':
	return checkFd();
	}
	}
	}.bind(this);

	var closer = setFSEventsListener(
	watchPath,
	realPath,
	watchCallback,
	this.emit.bind(this, 'raw')
	);

	this._emitReady();
	return closer;
	};

	// Private method: Handle symlinks encountered during directory scan

	// * linkPath - string, path to symlink
	// * fullPath - string, absolute path to the symlink
	// * transform - function, pre-existing path transformer
	// * curDepth - int, level of subdirectories traversed to where symlink is

	// Returns nothing
	FsEventsHandler.prototype._handleFsEventsSymlink =
	function(linkPath, fullPath, transform, curDepth) {
	// don't follow the same symlink more than once
	if (this._symlinkPaths[fullPath]) return;
	else this._symlinkPaths[fullPath] = true;

	this._readyCount++;

	fs.realpath(linkPath, function(error, linkTarget) {
	if (this._handleError(error) \|\| this._isIgnored(linkTarget)) {
	return this._emitReady();
	}

	this._readyCount++;

	// add the linkTarget for watching with a wrapper for transform
	// that causes emitted paths to incorporate the link's path
	this._addToFsEvents(linkTarget \|\| linkPath, function(path) {
	var dotSlash = '.' + sysPath.sep;
	var aliasedPath = linkPath;
	if (linkTarget && linkTarget !== dotSlash) {
	aliasedPath = path.replace(linkTarget, linkPath);
	} else if (path !== dotSlash) {
	aliasedPath = sysPath.join(linkPath, path);
	}
	return transform(aliasedPath);
	}, false, curDepth);
	}.bind(this));
	};

	// Private method: Handle added path with fsevents

	// * path - string, file/directory path or glob pattern
	// * transform - function, converts working path to what the user expects
	// * forceAdd - boolean, ensure add is emitted
	// * priorDepth - int, level of subdirectories already traversed

	// Returns nothing
	FsEventsHandler.prototype._addToFsEvents =
	function(path, transform, forceAdd, priorDepth) {

	// applies transform if provided, otherwise returns same value
	var processPath = typeof transform === 'function' ?
	transform : function(val) { return val; };

	var emitAdd = function(newPath, stats) {
	var pp = processPath(newPath);
	var isDir = stats.isDirectory();
	var dirObj = this._getWatchedDir(sysPath.dirname(pp));
	var base = sysPath.basename(pp);

	// ensure empty dirs get tracked
	if (isDir) this._getWatchedDir(pp);

	if (dirObj.has(base)) return;
	dirObj.add(base);

	if (!this.options.ignoreInitial \|\| forceAdd === true) {
	this._emit(isDir ? 'addDir' : 'add', pp, stats);
	}
	}.bind(this);

	var wh = this._getWatchHelpers(path);

	// evaluate what is at the path we're being asked to watch
	fs[wh.statMethod](wh.watchPath, function(error, stats) {
	if (this._handleError(error) \|\| this._isIgnored(wh.watchPath, stats)) {
	this._emitReady();
	return this._emitReady();
	}

	if (stats.isDirectory()) {
	// emit addDir unless this is a glob parent
	if (!wh.globFilter) emitAdd(processPath(path), stats);

	// don't recurse further if it would exceed depth setting
	if (priorDepth && priorDepth > this.options.depth) return;

	// scan the contents of the dir
	readdirp({
	root: wh.watchPath,
	entryType: 'all',
	fileFilter: wh.filterPath,
	directoryFilter: wh.filterDir,
	lstat: true,
	depth: this.options.depth - (priorDepth \|\| 0)
	}).on('data', function(entry) {
	// need to check filterPath on dirs b/c filterDir is less restrictive
	if (entry.stat.isDirectory() && !wh.filterPath(entry)) return;

	var joinedPath = sysPath.join(wh.watchPath, entry.path);
	var fullPath = entry.fullPath;

	if (wh.followSymlinks && entry.stat.isSymbolicLink()) {
	// preserve the current depth here since it can't be derived from
	// real paths past the symlink
	var curDepth = this.options.depth === undefined ?
	undefined : depth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;

	this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
	} else {
	emitAdd(joinedPath, entry.stat);
	}
	}.bind(this)).on('error', function() {
	// Ignore readdirp errors
	}).on('end', this._emitReady);
	} else {
	emitAdd(wh.watchPath, stats);
	this._emitReady();
	}
	}.bind(this));

	if (this.options.persistent && forceAdd !== true) {
	var initWatch = function(error, realPath) {
	if (this.closed) return;
	var closer = this._watchWithFsEvents(
	wh.watchPath,
	sysPath.resolve(realPath \|\| wh.watchPath),
	processPath,
	wh.globFilter
	);
	if (closer) {
	this._closers[path] = this._closers[path] \|\| [];
	this._closers[path].push(closer);
	}
	}.bind(this);

	if (typeof transform === 'function') {
	// realpath has already been resolved
	initWatch();
	} else {
	fs.realpath(wh.watchPath, initWatch);
	}
	}
	};

	module.exports = FsEventsHandler;
	module.exports.canUse = canUse;