text: 'use strict';
  
  const fs = require('fs');
  const path = require('path');
  const common = require('./common');
  const watchmanClient = require('./watchman_client');
  const EventEmitter = require('events').EventEmitter;
  const RecrawlWarning = require('./utils/recrawl-warning-dedupe');
  
  /**
   * Constants
   */
  
  const CHANGE_EVENT = common.CHANGE_EVENT;
  const DELETE_EVENT = common.DELETE_EVENT;
  const ADD_EVENT = common.ADD_EVENT;
  const ALL_EVENT = common.ALL_EVENT;
  
  /**
   * Export `WatchmanWatcher` class.
   */
  
  module.exports = WatchmanWatcher;
  
  /**
   * Watches `dir`.
   *
   * @class WatchmanWatcher
   * @param String dir
   * @param {Object} opts
   * @public
   */
  
  function WatchmanWatcher(dir, opts) {
    common.assignOptions(this, opts);
    this.root = path.resolve(dir);
    this._init();
  }
  
  WatchmanWatcher.prototype.__proto__ = EventEmitter.prototype;
  
  /**
   * Run the watchman `watch` command on the root and subscribe to changes.
   *
   * @private
   */
  WatchmanWatcher.prototype._init = function() {
    if (this._client) {
      this._client = null;
    }
  
    // Get the WatchmanClient instance corresponding to our watchmanPath (or nothing).
    // Then subscribe, which will do the appropriate setup so that we will receive
    // calls to handleChangeEvent when files change.
    this._client = watchmanClient.getInstance(this.watchmanPath);
  
    return this._client.subscribe(this, this.root).then(
      resp => {
        this._handleWarning(resp);
        this.emit('ready');
      },
      error => {
        this._handleError(error);
      }
    );
  };
  
  /**
   * Called by WatchmanClient to create the options, either during initial 'subscribe'
   * or to resubscribe after a disconnect+reconnect. Note that we are leaving out
   * the watchman 'since' and 'relative_root' options, which are handled inside the
   * WatchmanClient.
   */
  WatchmanWatcher.prototype.createOptions = function() {
    let options = {
      fields: ['name', 'exists', 'new'],
    };
  
    // If the server has the wildmatch capability available it supports
    // the recursive **/*.foo style match and we can offload our globs
    // to the watchman server.  This saves both on data size to be
    // communicated back to us and compute for evaluating the globs
    // in our node process.
    if (this._client.wildmatch) {
      if (this.globs.length === 0) {
        if (!this.dot) {
          // Make sure we honor the dot option if even we're not using globs.
          options.expression = [
            'match',
            '**',
            'wholename',
            {
              includedotfiles: false,
            },
          ];
        }
      } else {
        options.expression = ['anyof'];
        for (let i in this.globs) {
          options.expression.push([
            'match',
            this.globs[i],
            'wholename',
            {
              includedotfiles: this.dot,
            },
          ]);
        }
      }
    }
  
    return options;
  };
  
  /**
   * Called by WatchmanClient when it receives an error from the watchman daemon.
   *
   * @param {Object} resp
   */
  WatchmanWatcher.prototype.handleErrorEvent = function(error) {
    this.emit('error', error);
  };
  
  /**
   * Called by the WatchmanClient when it is notified about a file change in
   * the tree for this particular watcher's root.
   *
   * @param {Object} resp
   * @private
   */
  
  WatchmanWatcher.prototype.handleChangeEvent = function(resp) {
    if (Array.isArray(resp.files)) {
      resp.files.forEach(this.handleFileChange, this);
    }
  };
  
  /**
   * Handles a single change event record.
   *
   * @param {Object} changeDescriptor
   * @private
   */
  
  WatchmanWatcher.prototype.handleFileChange = function(changeDescriptor) {
    let absPath;
    let relativePath;
  
    relativePath = changeDescriptor.name;
    absPath = path.join(this.root, relativePath);
  
    if (
      !(this._client.wildmatch && !this.hasIgnore) &&
      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
    ) {
      return;
    }
  
    if (!changeDescriptor.exists) {
      this.emitEvent(DELETE_EVENT, relativePath, this.root);
    } else {
      fs.lstat(absPath, (error, stat) => {
        // Files can be deleted between the event and the lstat call
        // the most reliable thing to do here is to ignore the event.
        if (error && error.code === 'ENOENT') {
          return;
        }
  
        if (this._handleError(error)) {
          return;
        }
  
        let eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT;
  
        // Change event on dirs are mostly useless.
        if (!(eventType === CHANGE_EVENT && stat.isDirectory())) {
          this.emitEvent(eventType, relativePath, this.root, stat);
        }
      });
    }
  };
  
  /**
   * Dispatches an event.
   *
   * @param {string} eventType
   * @param {string} filepath
   * @param {string} root
   * @param {fs.Stat} stat
   * @private
   */
  
  WatchmanWatcher.prototype.emitEvent = function(
    eventType,
    filepath,
    root,
    stat
  ) {
    this.emit(eventType, filepath, root, stat);
    this.emit(ALL_EVENT, eventType, filepath, root, stat);
  };
  
  /**
   * Closes the watcher.
   *
   * @param {function} callback
   * @private
   */
  
  WatchmanWatcher.prototype.close = function(callback) {
    this._client.closeWatcher(this);
    callback && callback(null, true);
  };
  
  /**
   * Handles an error and returns true if exists.
   *
   * @param {WatchmanWatcher} self
   * @param {Error} error
   * @private
   */
  
  WatchmanWatcher.prototype._handleError = function(error) {
    if (error != null) {
      this.emit('error', error);
      return true;
    } else {
      return false;
    }
  };
  
  /**
   * Handles a warning in the watchman resp object.
   *
   * @param {object} resp
   * @private
   */
  
  WatchmanWatcher.prototype._handleWarning = function(resp) {
    if ('warning' in resp) {
      if (RecrawlWarning.isRecrawlWarningDupe(resp.warning)) {
        return true;
      }
      console.warn(resp.warning);
      return true;
    } else {
      return false;
    }
  };
  