api_connect_nodejs 1.0.0 → 2.0.1

package/test/EdelCsvTestSuite/node_modules/chokidar/index.js

@@ -1,973 +0,0 @@
-'use strict';
-
-const { EventEmitter } = require('events');
-const fs = require('fs');
-const sysPath = require('path');
-const { promisify } = require('util');
-const readdirp = require('readdirp');
-const anymatch = require('anymatch').default;
-const globParent = require('glob-parent');
-const isGlob = require('is-glob');
-const braces = require('braces');
-const normalizePath = require('normalize-path');
-
-const NodeFsHandler = require('./lib/nodefs-handler');
-const FsEventsHandler = require('./lib/fsevents-handler');
-const {
-  EV_ALL,
-  EV_READY,
-  EV_ADD,
-  EV_CHANGE,
-  EV_UNLINK,
-  EV_ADD_DIR,
-  EV_UNLINK_DIR,
-  EV_RAW,
-  EV_ERROR,
-
-  STR_CLOSE,
-  STR_END,
-
-  BACK_SLASH_RE,
-  DOUBLE_SLASH_RE,
-  SLASH_OR_BACK_SLASH_RE,
-  DOT_RE,
-  REPLACER_RE,
-
-  SLASH,
-  SLASH_SLASH,
-  BRACE_START,
-  BANG,
-  ONE_DOT,
-  TWO_DOTS,
-  GLOBSTAR,
-  SLASH_GLOBSTAR,
-  ANYMATCH_OPTS,
-  STRING_TYPE,
-  FUNCTION_TYPE,
-  EMPTY_STR,
-  EMPTY_FN,
-
-  isWindows,
-  isMacos,
-  isIBMi
-} = require('./lib/constants');
-
-const stat = promisify(fs.stat);
-const readdir = promisify(fs.readdir);
-
-/**
- * @typedef {String} Path
- * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
- * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
- */
-
-/**
- *
- * @typedef {Object} WatchHelpers
- * @property {Boolean} followSymlinks
- * @property {'stat'|'lstat'} statMethod
- * @property {Path} path
- * @property {Path} watchPath
- * @property {Function} entryPath
- * @property {Boolean} hasGlob
- * @property {Object} globFilter
- * @property {Function} filterPath
- * @property {Function} filterDir
- */
-
-const arrify = (value = []) => Array.isArray(value) ? value : [value];
-const flatten = (list, result = []) => {
-  list.forEach(item => {
-    if (Array.isArray(item)) {
-      flatten(item, result);
-    } else {
-      result.push(item);
-    }
-  });
-  return result;
-};
-
-const unifyPaths = (paths_) => {
-  /**
-   * @type {Array<String>}
-   */
-  const paths = flatten(arrify(paths_));
-  if (!paths.every(p => typeof p === STRING_TYPE)) {
-    throw new TypeError(`Non-string provided as watch path: ${paths}`);
-  }
-  return paths.map(normalizePathToUnix);
-};
-
-// If SLASH_SLASH occurs at the beginning of path, it is not replaced
-//     because "//StoragePC/DrivePool/Movies" is a valid network path
-const toUnix = (string) => {
-  let str = string.replace(BACK_SLASH_RE, SLASH);
-  let prepend = false;
-  if (str.startsWith(SLASH_SLASH)) {
-    prepend = true;
-  }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
-  }
-  if (prepend) {
-    str = SLASH + str;
-  }
-  return str;
-};
-
-// Our version of upath.normalize
-// TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
-
-const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
-  if (typeof path !== STRING_TYPE) return path;
-  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
-};
-
-const getAbsolutePath = (path, cwd) => {
-  if (sysPath.isAbsolute(path)) {
-    return path;
-  }
-  if (path.startsWith(BANG)) {
-    return BANG + sysPath.join(cwd, path.slice(1));
-  }
-  return sysPath.join(cwd, path);
-};
-
-const undef = (opts, key) => opts[key] === undefined;
-
-/**
- * Directory entry.
- * @property {Path} path
- * @property {Set<Path>} items
- */
-class DirEntry {
-  /**
-   * @param {Path} dir
-   * @param {Function} removeWatcher
-   */
-  constructor(dir, removeWatcher) {
-    this.path = dir;
-    this._removeWatcher = removeWatcher;
-    /** @type {Set<Path>} */
-    this.items = new Set();
-  }
-
-  add(item) {
-    const {items} = this;
-    if (!items) return;
-    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
-  }
-
-  async remove(item) {
-    const {items} = this;
-    if (!items) return;
-    items.delete(item);
-    if (items.size > 0) return;
-
-    const dir = this.path;
-    try {
-      await readdir(dir);
-    } catch (err) {
-      if (this._removeWatcher) {
-        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
-      }
-    }
-  }
-
-  has(item) {
-    const {items} = this;
-    if (!items) return;
-    return items.has(item);
-  }
-
-  /**
-   * @returns {Array<String>}
-   */
-  getChildren() {
-    const {items} = this;
-    if (!items) return;
-    return [...items.values()];
-  }
-
-  dispose() {
-    this.items.clear();
-    delete this.path;
-    delete this._removeWatcher;
-    delete this.items;
-    Object.freeze(this);
-  }
-}
-
-const STAT_METHOD_F = 'stat';
-const STAT_METHOD_L = 'lstat';
-class WatchHelper {
-  constructor(path, watchPath, follow, fsw) {
-    this.fsw = fsw;
-    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
-    this.watchPath = watchPath;
-    this.fullWatchPath = sysPath.resolve(watchPath);
-    this.hasGlob = watchPath !== path;
-    /** @type {object|boolean} */
-    if (path === EMPTY_STR) this.hasGlob = false;
-    this.globSymlink = this.hasGlob && follow ? undefined : false;
-    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
-    this.dirParts = this.getDirParts(path);
-    this.dirParts.forEach((parts) => {
-      if (parts.length > 1) parts.pop();
-    });
-    this.followSymlinks = follow;
-    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
-  }
-
-  checkGlobSymlink(entry) {
-    // only need to resolve once
-    // first entry should always have entry.parentDir === EMPTY_STR
-    if (this.globSymlink === undefined) {
-      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
-        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
-    }
-
-    if (this.globSymlink) {
-      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
-    }
-
-    return entry.fullPath;
-  }
-
-  entryPath(entry) {
-    return sysPath.join(this.watchPath,
-      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
-    );
-  }
-
-  filterPath(entry) {
-    const {stats} = entry;
-    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
-    const resolvedPath = this.entryPath(entry);
-    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
-      this.globFilter(resolvedPath) : true;
-    return matchesGlob &&
-      this.fsw._isntIgnored(resolvedPath, stats) &&
-      this.fsw._hasReadPermissions(stats);
-  }
-
-  getDirParts(path) {
-    if (!this.hasGlob) return [];
-    const parts = [];
-    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
-    expandedPath.forEach((path) => {
-      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
-    });
-    return parts;
-  }
-
-  filterDir(entry) {
-    if (this.hasGlob) {
-      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
-      let globstar = false;
-      this.unmatchedGlob = !this.dirParts.some((parts) => {
-        return parts.every((part, i) => {
-          if (part === GLOBSTAR) globstar = true;
-          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
-        });
-      });
-    }
-    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
-  }
-}
-
-/**
- * Watches files & directories for changes. Emitted events:
- * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
- *
- *     new FSWatcher()
- *       .add(directories)
- *       .on('add', path => log('File', path, 'was added'))
- */
-class FSWatcher extends EventEmitter {
-// Not indenting methods for history sake; for now.
-constructor(_opts) {
-  super();
-
-  const opts = {};
-  if (_opts) Object.assign(opts, _opts); // for frozen objects
-
-  /** @type {Map<String, DirEntry>} */
-  this._watched = new Map();
-  /** @type {Map<String, Array>} */
-  this._closers = new Map();
-  /** @type {Set<String>} */
-  this._ignoredPaths = new Set();
-
-  /** @type {Map<ThrottleType, Map>} */
-  this._throttled = new Map();
-
-  /** @type {Map<Path, String|Boolean>} */
-  this._symlinkPaths = new Map();
-
-  this._streams = new Set();
-  this.closed = false;
-
-  // Set up default options.
-  if (undef(opts, 'persistent')) opts.persistent = true;
-  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
-  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
-  if (undef(opts, 'interval')) opts.interval = 100;
-  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
-  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
-  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
-
-  // Enable fsevents on OS X when polling isn't explicitly enabled.
-  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
-
-  // If we can't use fsevents, ensure the options reflect it's disabled.
-  const canUseFsEvents = FsEventsHandler.canUse();
-  if (!canUseFsEvents) opts.useFsEvents = false;
-
-  // Use polling on Mac if not using fsevents.
-  // Other platforms use non-polling fs_watch.
-  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
-    opts.usePolling = isMacos;
-  }
-
-  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
-  if(isIBMi) {
-    opts.usePolling = true;
-  }
-
-  // Global override (useful for end-developers that need to force polling for all
-  // instances of chokidar, regardless of usage/dependency depth)
-  const envPoll = process.env.CHOKIDAR_USEPOLLING;
-  if (envPoll !== undefined) {
-    const envLower = envPoll.toLowerCase();
-
-    if (envLower === 'false' || envLower === '0') {
-      opts.usePolling = false;
-    } else if (envLower === 'true' || envLower === '1') {
-      opts.usePolling = true;
-    } else {
-      opts.usePolling = !!envLower;
-    }
-  }
-  const envInterval = process.env.CHOKIDAR_INTERVAL;
-  if (envInterval) {
-    opts.interval = Number.parseInt(envInterval, 10);
-  }
-
-  // Editor atomic write normalization enabled by default with fs.watch
-  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
-  if (opts.atomic) this._pendingUnlinks = new Map();
-
-  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
-
-  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
-  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
-  const awf = opts.awaitWriteFinish;
-  if (awf) {
-    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
-    if (!awf.pollInterval) awf.pollInterval = 100;
-    this._pendingWrites = new Map();
-  }
-  if (opts.ignored) opts.ignored = arrify(opts.ignored);
-
-  let readyCalls = 0;
-  this._emitReady = () => {
-    readyCalls++;
-    if (readyCalls >= this._readyCount) {
-      this._emitReady = EMPTY_FN;
-      this._readyEmitted = true;
-      // use process.nextTick to allow time for listener to be bound
-      process.nextTick(() => this.emit(EV_READY));
-    }
-  };
-  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
-  this._readyEmitted = false;
-  this.options = opts;
-
-  // Initialize with proper watcher.
-  if (opts.useFsEvents) {
-    this._fsEventsHandler = new FsEventsHandler(this);
-  } else {
-    this._nodeFsHandler = new NodeFsHandler(this);
-  }
-
-  // You’re frozen when your heart’s not open.
-  Object.freeze(opts);
-}
-
-// Public methods
-
-/**
- * Adds paths to be watched on an existing FSWatcher instance
- * @param {Path|Array<Path>} paths_
- * @param {String=} _origAdd private; for handling non-existent paths to be watched
- * @param {Boolean=} _internal private; indicates a non-user add
- * @returns {FSWatcher} for chaining
- */
-add(paths_, _origAdd, _internal) {
-  const {cwd, disableGlobbing} = this.options;
-  this.closed = false;
-  let paths = unifyPaths(paths_);
-  if (cwd) {
-    paths = paths.map((path) => {
-      const absPath = getAbsolutePath(path, cwd);
-
-      // Check `path` instead of `absPath` because the cwd portion can't be a glob
-      if (disableGlobbing || !isGlob(path)) {
-        return absPath;
-      }
-      return normalizePath(absPath);
-    });
-  }
-
-  // set aside negated glob strings
-  paths = paths.filter((path) => {
-    if (path.startsWith(BANG)) {
-      this._ignoredPaths.add(path.slice(1));
-      return false;
-    }
-
-    // if a path is being added that was previously ignored, stop ignoring it
-    this._ignoredPaths.delete(path);
-    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
-
-    // reset the cached userIgnored anymatch fn
-    // to make ignoredPaths changes effective
-    this._userIgnored = undefined;
-
-    return true;
-  });
-
-  if (this.options.useFsEvents && this._fsEventsHandler) {
-    if (!this._readyCount) this._readyCount = paths.length;
-    if (this.options.persistent) this._readyCount *= 2;
-    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
-  } else {
-    if (!this._readyCount) this._readyCount = 0;
-    this._readyCount += paths.length;
-    Promise.all(
-      paths.map(async path => {
-        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
-        if (res) this._emitReady();
-        return res;
-      })
-    ).then(results => {
-      if (this.closed) return;
-      results.filter(item => item).forEach(item => {
-        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
-      });
-    });
-  }
-
-  return this;
-}
-
-/**
- * Close watchers or start ignoring events from specified paths.
- * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
- * @returns {FSWatcher} for chaining
-*/
-unwatch(paths_) {
-  if (this.closed) return this;
-  const paths = unifyPaths(paths_);
-  const {cwd} = this.options;
-
-  paths.forEach((path) => {
-    // convert to absolute path unless relative path already matches
-    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
-      if (cwd) path = sysPath.join(cwd, path);
-      path = sysPath.resolve(path);
-    }
-
-    this._closePath(path);
-
-    this._ignoredPaths.add(path);
-    if (this._watched.has(path)) {
-      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
-    }
-
-    // reset the cached userIgnored anymatch fn
-    // to make ignoredPaths changes effective
-    this._userIgnored = undefined;
-  });
-
-  return this;
-}
-
-/**
- * Close watchers and remove all listeners from watched paths.
- * @returns {Promise<void>}.
-*/
-close() {
-  if (this.closed) return this._closePromise;
-  this.closed = true;
-
-  // Memory management.
-  this.removeAllListeners();
-  const closers = [];
-  this._closers.forEach(closerList => closerList.forEach(closer => {
-    const promise = closer();
-    if (promise instanceof Promise) closers.push(promise);
-  }));
-  this._streams.forEach(stream => stream.destroy());
-  this._userIgnored = undefined;
-  this._readyCount = 0;
-  this._readyEmitted = false;
-  this._watched.forEach(dirent => dirent.dispose());
-  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
-    this[`_${key}`].clear();
-  });
-
-  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
-  return this._closePromise;
-}
-
-/**
- * Expose list of watched paths
- * @returns {Object} for chaining
-*/
-getWatched() {
-  const watchList = {};
-  this._watched.forEach((entry, dir) => {
-    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
-    watchList[key || ONE_DOT] = entry.getChildren().sort();
-  });
-  return watchList;
-}
-
-emitWithAll(event, args) {
-  this.emit(...args);
-  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
-}
-
-// Common helpers
-// --------------
-
-/**
- * Normalize and emit events.
- * Calling _emit DOES NOT MEAN emit() would be called!
- * @param {EventName} event Type of event
- * @param {Path} path File or directory path
- * @param {*=} val1 arguments to be passed with event
- * @param {*=} val2
- * @param {*=} val3
- * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
- */
-async _emit(event, path, val1, val2, val3) {
-  if (this.closed) return;
-
-  const opts = this.options;
-  if (isWindows) path = sysPath.normalize(path);
-  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
-  /** @type Array<any> */
-  const args = [event, path];
-  if (val3 !== undefined) args.push(val1, val2, val3);
-  else if (val2 !== undefined) args.push(val1, val2);
-  else if (val1 !== undefined) args.push(val1);
-
-  const awf = opts.awaitWriteFinish;
-  let pw;
-  if (awf && (pw = this._pendingWrites.get(path))) {
-    pw.lastChange = new Date();
-    return this;
-  }
-
-  if (opts.atomic) {
-    if (event === EV_UNLINK) {
-      this._pendingUnlinks.set(path, args);
-      setTimeout(() => {
-        this._pendingUnlinks.forEach((entry, path) => {
-          this.emit(...entry);
-          this.emit(EV_ALL, ...entry);
-          this._pendingUnlinks.delete(path);
-        });
-      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
-      return this;
-    }
-    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
-      event = args[0] = EV_CHANGE;
-      this._pendingUnlinks.delete(path);
-    }
-  }
-
-  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
-    const awfEmit = (err, stats) => {
-      if (err) {
-        event = args[0] = EV_ERROR;
-        args[1] = err;
-        this.emitWithAll(event, args);
-      } else if (stats) {
-        // if stats doesn't exist the file must have been deleted
-        if (args.length > 2) {
-          args[2] = stats;
-        } else {
-          args.push(stats);
-        }
-        this.emitWithAll(event, args);
-      }
-    };
-
-    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
-    return this;
-  }
-
-  if (event === EV_CHANGE) {
-    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
-    if (isThrottled) return this;
-  }
-
-  if (opts.alwaysStat && val1 === undefined &&
-    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
-  ) {
-    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
-    let stats;
-    try {
-      stats = await stat(fullPath);
-    } catch (err) {}
-    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
-    if (!stats || this.closed) return;
-    args.push(stats);
-  }
-  this.emitWithAll(event, args);
-
-  return this;
-}
-
-/**
- * Common handler for errors
- * @param {Error} error
- * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
- */
-_handleError(error) {
-  const code = error && error.code;
-  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
-    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
-  ) {
-    this.emit(EV_ERROR, error);
-  }
-  return error || this.closed;
-}
-
-/**
- * Helper utility for throttling
- * @param {ThrottleType} actionType type being throttled
- * @param {Path} path being acted upon
- * @param {Number} timeout duration of time to suppress duplicate actions
- * @returns {Object|false} tracking object or false if action should be suppressed
- */
-_throttle(actionType, path, timeout) {
-  if (!this._throttled.has(actionType)) {
-    this._throttled.set(actionType, new Map());
-  }
-
-  /** @type {Map<Path, Object>} */
-  const action = this._throttled.get(actionType);
-  /** @type {Object} */
-  const actionPath = action.get(path);
-
-  if (actionPath) {
-    actionPath.count++;
-    return false;
-  }
-
-  let timeoutObject;
-  const clear = () => {
-    const item = action.get(path);
-    const count = item ? item.count : 0;
-    action.delete(path);
-    clearTimeout(timeoutObject);
-    if (item) clearTimeout(item.timeoutObject);
-    return count;
-  };
-  timeoutObject = setTimeout(clear, timeout);
-  const thr = {timeoutObject, clear, count: 0};
-  action.set(path, thr);
-  return thr;
-}
-
-_incrReadyCount() {
-  return this._readyCount++;
-}
-
-/**
- * Awaits write operation to finish.
- * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
- * @param {Path} path being acted upon
- * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
- * @param {EventName} event
- * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
- */
-_awaitWriteFinish(path, threshold, event, awfEmit) {
-  let timeoutHandler;
-
-  let fullPath = path;
-  if (this.options.cwd && !sysPath.isAbsolute(path)) {
-    fullPath = sysPath.join(this.options.cwd, path);
-  }
-
-  const now = new Date();
-
-  const awaitWriteFinish = (prevStat) => {
-    fs.stat(fullPath, (err, curStat) => {
-      if (err || !this._pendingWrites.has(path)) {
-        if (err && err.code !== 'ENOENT') awfEmit(err);
-        return;
-      }
-
-      const now = Number(new Date());
-
-      if (prevStat && curStat.size !== prevStat.size) {
-        this._pendingWrites.get(path).lastChange = now;
-      }
-      const pw = this._pendingWrites.get(path);
-      const df = now - pw.lastChange;
-
-      if (df >= threshold) {
-        this._pendingWrites.delete(path);
-        awfEmit(undefined, curStat);
-      } else {
-        timeoutHandler = setTimeout(
-          awaitWriteFinish,
-          this.options.awaitWriteFinish.pollInterval,
-          curStat
-        );
-      }
-    });
-  };
-
-  if (!this._pendingWrites.has(path)) {
-    this._pendingWrites.set(path, {
-      lastChange: now,
-      cancelWait: () => {
-        this._pendingWrites.delete(path);
-        clearTimeout(timeoutHandler);
-        return event;
-      }
-    });
-    timeoutHandler = setTimeout(
-      awaitWriteFinish,
-      this.options.awaitWriteFinish.pollInterval
-    );
-  }
-}
-
-_getGlobIgnored() {
-  return [...this._ignoredPaths.values()];
-}
-
-/**
- * Determines whether user has asked to ignore this path.
- * @param {Path} path filepath or dir
- * @param {fs.Stats=} stats result of fs.stat
- * @returns {Boolean}
- */
-_isIgnored(path, stats) {
-  if (this.options.atomic && DOT_RE.test(path)) return true;
-  if (!this._userIgnored) {
-    const {cwd} = this.options;
-    const ign = this.options.ignored;
-
-    const ignored = ign && ign.map(normalizeIgnored(cwd));
-    const paths = arrify(ignored)
-      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
-      .map((path) => path + SLASH_GLOBSTAR);
-    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
-    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
-  }
-
-  return this._userIgnored([path, stats]);
-}
-
-_isntIgnored(path, stat) {
-  return !this._isIgnored(path, stat);
-}
-
-/**
- * Provides a set of common helpers and properties relating to symlink and glob handling.
- * @param {Path} path file, directory, or glob pattern being watched
- * @param {Number=} depth at any depth > 0, this isn't a glob
- * @returns {WatchHelper} object containing helpers for this path
- */
-_getWatchHelpers(path, depth) {
-  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
-  const follow = this.options.followSymlinks;
-
-  return new WatchHelper(path, watchPath, follow, this);
-}
-
-// Directory helpers
-// -----------------
-
-/**
- * Provides directory tracking objects
- * @param {String} directory path of the directory
- * @returns {DirEntry} the directory's tracking object
- */
-_getWatchedDir(directory) {
-  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
-  const dir = sysPath.resolve(directory);
-  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-  return this._watched.get(dir);
-}
-
-// File helpers
-// ------------
-
-/**
- * Check for read permissions.
- * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
- * @param {fs.Stats} stats - object, result of fs_stat
- * @returns {Boolean} indicates whether the file can be read
-*/
-_hasReadPermissions(stats) {
-  if (this.options.ignorePermissionErrors) return true;
-
-  // stats.mode may be bigint
-  const md = stats && Number.parseInt(stats.mode, 10);
-  const st = md & 0o777;
-  const it = Number.parseInt(st.toString(8)[0], 10);
-  return Boolean(4 & it);
-}
-
-/**
- * Handles emitting unlink events for
- * files and directories, and via recursion, for
- * files and directories within directories that are unlinked
- * @param {String} directory within which the following item is located
- * @param {String} item      base path of item/directory
- * @returns {void}
-*/
-_remove(directory, item, isDirectory) {
-  // if what is being deleted is a directory, get that directory's paths
-  // for recursive deleting and cleaning of watched object
-  // if it is not a directory, nestedDirectoryChildren will be empty array
-  const path = sysPath.join(directory, item);
-  const fullPath = sysPath.resolve(path);
-  isDirectory = isDirectory != null
-    ? isDirectory
-    : this._watched.has(path) || this._watched.has(fullPath);
-
-  // prevent duplicate handling in case of arriving here nearly simultaneously
-  // via multiple paths (such as _handleFile and _handleDir)
-  if (!this._throttle('remove', path, 100)) return;
-
-  // if the only watched file is removed, watch for its return
-  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
-    this.add(directory, item, true);
-  }
-
-  // This will create a new entry in the watched object in either case
-  // so we got to do the directory check beforehand
-  const wp = this._getWatchedDir(path);
-  const nestedDirectoryChildren = wp.getChildren();
-
-  // Recursively remove children directories / files.
-  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
-
-  // Check if item was on the watched list and remove it
-  const parent = this._getWatchedDir(directory);
-  const wasTracked = parent.has(item);
-  parent.remove(item);
-
-  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
-  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
-  // but never removed from the map in case the path was deleted.
-  // This leads to an incorrect state if the path was recreated:
-  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
-  if (this._symlinkPaths.has(fullPath)) {
-    this._symlinkPaths.delete(fullPath);
-  }
-
-  // If we wait for this file to be fully written, cancel the wait.
-  let relPath = path;
-  if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
-  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-    const event = this._pendingWrites.get(relPath).cancelWait();
-    if (event === EV_ADD) return;
-  }
-
-  // The Entry will either be a directory that just got removed
-  // or a bogus entry to a file, in either case we have to remove it
-  this._watched.delete(path);
-  this._watched.delete(fullPath);
-  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
-  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
-
-  // Avoid conflicts if we later create another file with the same name
-  if (!this.options.useFsEvents) {
-    this._closePath(path);
-  }
-}
-
-/**
- * Closes all watchers for a path
- * @param {Path} path
- */
-_closePath(path) {
-  this._closeFile(path)
-  const dir = sysPath.dirname(path);
-  this._getWatchedDir(dir).remove(sysPath.basename(path));
-}
-
-/**
- * Closes only file-specific watchers
- * @param {Path} path
- */
-_closeFile(path) {
-  const closers = this._closers.get(path);
-  if (!closers) return;
-  closers.forEach(closer => closer());
-  this._closers.delete(path);
-}
-
-/**
- *
- * @param {Path} path
- * @param {Function} closer
- */
-_addPathCloser(path, closer) {
-  if (!closer) return;
-  let list = this._closers.get(path);
-  if (!list) {
-    list = [];
-    this._closers.set(path, list);
-  }
-  list.push(closer);
-}
-
-_readdirp(root, opts) {
-  if (this.closed) return;
-  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
-  let stream = readdirp(root, options);
-  this._streams.add(stream);
-  stream.once(STR_CLOSE, () => {
-    stream = undefined;
-  });
-  stream.once(STR_END, () => {
-    if (stream) {
-      this._streams.delete(stream);
-      stream = undefined;
-    }
-  });
-  return stream;
-}
-
-}
-
-// Export FSWatcher class
-exports.FSWatcher = FSWatcher;
-
-/**
- * Instantiates watcher with paths to be tracked.
- * @param {String|Array<String>} paths file/directory paths and/or globs
- * @param {Object=} options chokidar opts
- * @returns an instance of FSWatcher for chaining.
- */
-const watch = (paths, options) => {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths);
-  return watcher;
-};
-
-exports.watch = watch;