/* compromise-sentences 0.1.1 MIT */
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.compromiseSentences = factory());
}(this, (function () { 'use strict';

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _createSuper(Derived) {
    var hasNativeReflectConstruct = _isNativeReflectConstruct();

    return function _createSuperInternal() {
      var Super = _getPrototypeOf(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = _getPrototypeOf(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return _possibleConstructorReturn(this, result);
    };
  }

  var tags = {
    // Phrase: {},
    NounPhrase: {
      // isA: 'Phrase',
      notA: ['VerbPhrase', 'AdjectivePhrase'],
      color: 'blue'
    },
    VerbPhrase: {
      // isA: 'Phrase',
      notA: ['AdjectivePhrase', 'NounPhrase'],
      color: 'green'
    },
    AdjectivePhrase: {
      // isA: 'Phrase',
      notA: ['VerbPhrase', 'NounPhrase'],
      color: 'magenta'
    },
    Subordinate: {
      // isA: 'Phrase',
      notA: [] // color: '',

    }
  };

  var tagger = function tagger(doc) {
    doc.match('#Noun').tag('NounPhrase');
    doc.match('#Verb').tag('VerbPhrase'); // NounPhrase

    doc.match('(this|that|those|these)').tag('NounPhrase');
    doc.match('#Adjective+ #NounPhrase').tagSafe('NounPhrase');
    doc.match('#NounPhrase #Adjective+').tagSafe('NounPhrase'); // numbers

    doc.match('#Value #NounPhrase').tag('NounPhrase'); // (determiners)

    doc.match('#Determiner #NounPhrase').tag('NounPhrase');
    doc.match('#Determiner #Adverb+? #Adjective+ #NounPhrase').tag('NounPhrase');
    doc.match('(many|most|all|one|some|plenty) of #NounPhrase').tag('NounPhrase');
    doc.match('such a #NounPhrase').tag('NounPhrase'); // VerbPhrase

    doc.match('#VerbPhrase #Adverb+').tagSafe('VerbPhrase');
    doc.match('#Adverb+ #VerbPhrase').tagSafe('VerbPhrase');
    doc.match('#Auxiliary+ #VerbPhrase').tagSafe('VerbPhrase');
    doc.match('#VerbPhrase no').tagSafe('VerbPhrase');
    doc.match('not #VerbPhrase').tagSafe('VerbPhrase'); // claiming that

    doc.match('#VerbPhrase [that]', 0).unTag('NounPhrase'); // (conjunctions)

    doc.match('#VerbPhrase #Conjunction #VerbPhrase').tagSafe('VerbPhrase'); // nouns

    doc.match('(who|what|which)').tag('NounPhrase'); // Adjective

    doc.match('#Adverb+ #Adjective').tagSafe('AdjectivePhrase');
    doc.match('#Adjective').tagSafe('AdjectivePhrase'); // missing

    doc.match('#Value').tagSafe('NounPhrase');
    doc.match('#Date').tagSafe('NounPhrase');
    doc.match('#Date at #Date').tagSafe('NounPhrase');
  };

  var tagger_1 = tagger;

  /** add a word to the start of this sentence */
  var prepend = function prepend(str) {
    this.forEach(function (doc) {
      // repair the titlecase
      var firstTerms = doc.match('^.');
      firstTerms.not('#ProperNoun').toLowerCase(); // actually add the word

      firstTerms._prepend(str); // add a titlecase


      firstTerms.terms(0).toTitleCase();
    });
    return this;
  };
  /** add a word to the end of this sentence */


  var append_1 = function append_1(str) {
    var hasEnd = /[.?!]\s*$/.test(str);
    this.forEach(function (doc) {
      var end = doc.match('.$');
      var lastTerm = end.termList(0);
      var punct = lastTerm.post;

      if (hasEnd === true) {
        punct = '';
      } // add punctuation to the end


      end._append(str + punct); // remove punctuation from the former last-term


      lastTerm.post = ' ';
    });
    return this;
  };

  var append = {
    prepend: prepend,
    append: append_1
  };

  // if a clause starts with these, it's not a main clause
  var subordinate = "(after|although|as|because|before|if|since|than|that|though|when|whenever|where|whereas|wherever|whether|while|why|unless|until|once)";
  var relative = "(that|which|whichever|who|whoever|whom|whose|whomever)"; //try to remove secondary clauses

  var mainClause = function mainClause(og) {
    var m = og.clone(true);

    if (m.length === 1) {
      return m;
    } // if there's no verb?


    m = m["if"]('#Verb');

    if (m.length === 1) {
      return m;
    } // this is a signal for subordinate-clauses


    m = m.ifNo(subordinate);
    m = m.ifNo('^even (if|though)');
    m = m.ifNo('^so that');
    m = m.ifNo('^rather than');
    m = m.ifNo('^provided that');

    if (m.length === 1) {
      return m;
    } // relative clauses


    m = m.ifNo(relative);

    if (m.length === 1) {
      return m;
    }

    m = m.ifNo('(despite|during|before|through|throughout)');

    if (m.length === 1) {
      return m;
    } // did we go too far?


    if (m.length === 0) {
      m = og;
    } // choose the first one?


    return m.eq(0);
  };

  var mainClause_1 = mainClause;

  var parse = function parse(doc) {
    var clauses = doc.clauses();
    var main = mainClause_1(clauses);
    var nouns = main.match('#Determiner? (#Noun|#Adjective)+')["if"]('#Noun');
    var verb = main.verbs().eq(0); // match('(do|will)? not? #Verb+ not?').eq(0)

    return {
      subject: nouns.eq(0),
      verb: verb,
      object: verb.lookAhead('.*')
    };
  };

  var parse_1 = parse;

  /** overload the original json with noun information */

  var json_1 = function json_1(options) {
    var n = null;

    if (typeof options === 'number') {
      n = options;
      options = null;
    }

    options = options || {
      text: true,
      normal: true,
      trim: true,
      terms: true
    };
    var res = [];
    this.forEach(function (doc) {
      var json = doc._json(options)[0];

      var obj = parse_1(doc);
      json.subject = obj.subject.json(options)[0];
      json.verb = obj.verb.json(options)[0];
      json.object = obj.object.json(options)[0];
      res.push(json);
    });

    if (n !== null) {
      return res[n];
    }

    return res;
  };

  var json = {
    json: json_1
  };

  /** he walks -> he did not walk */

  var toNegative = function toNegative() {
    this.forEach(function (doc) {
      var obj = parse_1(doc);
      var vb = obj.verb.clone();
      vb = vb.verbs().toNegative();
      obj.verb.replaceWith(vb, false);
    });
    return this;
  };
  /** he doesn't walk -> he walks */


  var toPositive = function toPositive() {
    this.forEach(function (doc) {
      var obj = parse_1(doc);
      var vb = obj.verb.clone();
      vb = vb.verbs().toPositive();
      obj.verb.replaceWith(vb, false);
    });
    return this;
  };

  var negative = {
    toNegative: toNegative,
    toPositive: toPositive
  };

  //is this sentence asking a question?
  var isQuestion = function isQuestion(doc) {
    var endPunct = doc.post();
    var clauses = doc.clauses();

    if (/\?/.test(endPunct) === true) {
      return true;
    } // Has ellipsis at the end means it's probably not a question
    // e.g., Is this just fantasy...


    if (/\.\.$/.test(doc.out('text'))) {
      return false;
    } // Starts with question word, but has a comma, so probably not a question
    // e.g., Why are we caught in a land slide, no escape from reality


    if (doc.has('^#QuestionWord') && doc.has('#Comma')) {
      return false;
    } // Starts with a #QuestionWord
    // e.g., What open your eyes look up to the skies and see


    if (doc.has('^#QuestionWord')) {
      return true;
    } // Second word is a #QuestionWord
    // e.g., I'm what a poor boy
    // case ts.has('^\w+\s#QuestionWord'):
    // return true;
    // is it, do you - start of sentence
    // e.g., Do I need no sympathy


    if (doc.has('^(do|does|did|is|was|can|could|will|would|may) #Noun')) {
      return true;
    } // these are a little more loose..
    // e.g., Must I be come easy come easy go


    if (doc.has('^(have|must) you')) {
      return true;
    } // Clause starts with a question word
    // e.g., Anyway the wind blows, what doesn't really matter to me


    if (clauses.has('^#QuestionWord')) {
      return true;
    } //is wayne gretskzy alive


    if (clauses.has('(do|does|is|was) #Noun+ #Adverb? (#Adjective|#Infinitive)$')) {
      return true;
    } // Probably not a question


    return false;
  };

  var isQuestion_1 = isQuestion;

  /** return sentences ending with '?' */

  var isQuestion_1$1 = function isQuestion_1$1() {
    return this.filter(function (d) {
      return isQuestion_1(d);
    });
  };
  /** return sentences ending with '!' */


  var isExclamation = function isExclamation() {
    return this.filter(function (doc) {
      var term = doc.lastTerm().termList(0);
      return term.hasPost('!');
    });
  };
  /** return sentences with neither a question or an exclamation */


  var isStatement = function isStatement() {
    return this.filter(function (doc) {
      var term = doc.lastTerm().termList(0);
      return !term.hasPost('?') && !term.hasPost('!');
    });
  };
  /** 'he is.' -> 'he is!' */


  var toExclamation = function toExclamation() {
    this.post('!');
    return this;
  };
  /** 'he is.' -> 'he is?' */


  var toQuestion = function toQuestion() {
    this.post('?');
    return this;
  };
  /** 'he is?' -> 'he is.' */


  var toStatement = function toStatement() {
    this.post('.');
    return this;
  };

  var questions = {
    isQuestion: isQuestion_1$1,
    isExclamation: isExclamation,
    isStatement: isStatement,
    toExclamation: toExclamation,
    toQuestion: toQuestion,
    toStatement: toStatement
  };

  var useParticiple = function useParticiple(vb) {
    if (vb.has('(could|should|would|may|can|must)')) {
      return true;
    }

    return false;
  };
  /** he walks -> he walked */


  var toPastTense = function toPastTense() {
    this.forEach(function (doc) {
      if (doc.has('#PastTense')) {
        return;
      }

      var obj = parse_1(doc);
      var vb = obj.verb.clone(); // support 'he could drive' -> 'he could have driven'

      if (useParticiple(vb)) {
        vb = vb.verbs().toParticiple();
        obj.verb.replaceWith(vb, false);
      } else {
        //   //do a normal conjugation
        vb = vb.verbs().toPastTense();
        obj.verb.replaceWith(vb, false);
      } // // trailing gerund/future/present are okay, but 'walked and eats' is not


      if (obj.object && obj.object.found && obj.object.has('#PresentTense')) {
        var verbs = obj.object.verbs();
        verbs["if"]('#PresentTense').verbs().toPastTense();
      }
    });
    return this;
  };
  /** he drives -> he has driven */


  var toParticiple = function toParticiple() {
    this.forEach(function (doc) {
      if (doc.has('has #Participle')) {
        return;
      }

      var obj = parse_1(doc);
      var vb = obj.verb.clone();
      vb = vb.verbs().toParticiple();
      obj.verb.replaceWith(vb, false); // trailing gerund/future/present are okay, but 'walked and eats' is not

      if (obj.object && obj.object.found && obj.object.has('#PresentTense')) {
        var verbs = obj.object.verbs();
        verbs["if"]('#PresentTense').verbs().toParticiple();
      }
    });
    return this;
  };
  /** he walked -> he walks */


  var toPresentTense = function toPresentTense() {
    this.forEach(function (doc) {
      var obj = parse_1(doc);
      var isPlural = obj.verb.lookBehind('(i|we) (#Adverb|#Verb)?$').found;
      var vb = obj.verb.clone(); // 'i look', not 'i looks'

      if (isPlural) {
        //quick hack for copula verb - be/am
        if (vb.has('(is|was|am|be)')) {
          vb = vb.replace('will? (is|was|am|be)', 'am');
        } else {
          vb = vb.verbs().toInfinitive();
        }
      } else {
        //'he looks'
        vb = vb.verbs().toPresentTense();
      }

      obj.verb.replaceWith(vb, false); // future is okay, but 'walks and ate' -> 'walks and eats'

      if (obj.object && obj.object.found && obj.object.has('#PastTense')) {
        var verbs = obj.object.verbs();
        verbs["if"]('#PastTense').verbs().toPresentTense();
      }
    });
    return this;
  };
  /**he walked -> he will walk */


  var toFutureTense = function toFutureTense() {
    this.forEach(function (doc) {
      var obj = parse_1(doc);
      var vb = obj.verb.clone();
      vb = vb.verbs().toFutureTense();
      obj.verb.replaceWith(vb, false); //Present is okay, but 'will walk and ate' -> 'will walk and eat'

      if (obj.object && obj.object.found && obj.object.has('(#PastTense|#PresentTense)')) {
        var verbs = obj.object.verbs();
        verbs["if"]('(#PastTense|#PresentTense)').verbs().toInfinitive();
      }
    });
    return this;
  };
  /** the main noun of the sentence */


  var subjects = function subjects() {
    return this.map(function (doc) {
      var res = parse_1(doc);
      return res.subject;
    });
  };
  /** return sentences that are in passive-voice */


  var isPassive = function isPassive() {
    return this["if"]('was #Adverb? #PastTense #Adverb? by'); //haha
  };

  var tense = {
    toPastTense: toPastTense,
    toParticiple: toParticiple,
    toPresentTense: toPresentTense,
    toFutureTense: toFutureTense,
    subjects: subjects,
    isPassive: isPassive
  };

  var phrases_1 = function phrases_1() {
    var arr = [];
    this.forEach(function (s) {
      s = s.splitOn('#VerbPhrase+');
      s = s.splitOn('#NounPhrase+');
      s = s.splitOn('#AdjectivePhrase+');
      arr = arr.concat(s.list);
    });
    return this.buildFrom(arr);
  };

  var phrases = {
    phrases: phrases_1
  };

  var methods = Object.assign({}, append, json, negative, questions, tense, phrases);

  var plugin = function plugin(Doc, world) {
    // our new tags
    world.addTags(tags); // run our tagger

    world.postProcess(tagger_1);
    /**  */

    var Sentences = /*#__PURE__*/function (_Doc) {
      _inherits(Sentences, _Doc);

      var _super = _createSuper(Sentences);

      function Sentences(list, from, w) {
        _classCallCheck(this, Sentences);

        list = list.map(function (p) {
          return p.clone(true);
        });
        return _super.call(this, list, from, w);
      }

      return Sentences;
    }(Doc); // add some aliases


    methods.questions = methods.isQuestion;
    methods.exclamations = methods.isExclamation;
    methods.statements = methods.isStatement; // keep backups of these methods

    methods._prepend = Sentences.prototype.prepend;
    methods._append = Sentences.prototype.append;
    methods._json = Sentences.prototype.json;
    Object.assign(Sentences.prototype, methods);
    /** create a new Sentences object */

    Sentences.prototype.buildFrom = function (list) {
      list = list.map(function (p) {
        return p.clone(true);
      });
      var doc = new Sentences(list, this, this.world);
      return doc;
    };
    /** create a new Doc object */


    Sentences.prototype.toDoc = function () {
      return Doc.prototype.buildFrom(this.list);
    };
    /** overload original sentences() method and return Sentence class**/


    Doc.prototype.sentences = function (n) {
      var arr = [];
      this.list.forEach(function (p) {
        arr.push(p.fullSentence());
      });
      var s = new Sentences(arr, this, this.world);

      if (typeof n === 'number') {
        s = s.get(n);
      }

      return s;
    };

    return Doc;
  };

  var src = plugin;

  return src;

})));
//# sourceMappingURL=compromise-sentences.js.map