];
  }

  function assertImpl (value, message, ErrorType) {
    if (value) {
      return value;
    }
    throw new (ErrorType || Error)(message || 'Assertion failed');
  }

  /**
   * Public modifier `not`.
   *
   * Negates `predicate`.
   */
  function notModifier (predicate) {
    var modifiedPredicate = function () {
      return notImpl(predicate.apply(null, arguments));
    };
    modifiedPredicate.l = predicate.length;
    return modifiedPredicate;
  }

  function notImpl (value) {
    return!value;
  }

  /**
   * Public modifier `maybe`.
   *
   * Returns true if predicate argument is  null or undefined,
   * otherwise propagates the return value from `predicate`.
   */
  function maybeModifier (predicate) {
    var modifiedPredicate = function () {
      if (not.assigned(arguments[0])) {
        return true;
      }

      return predicate.apply(null, arguments);
    };
    modifiedPredicate.l = predicate.length;

    // Hackishly indicate that this is a maybe.xxx predicate.
    // Without this flag, the alternative would be to iterate
    // through the maybe predicates or use indexOf to check,
    // which would be time-consuming.
    modifiedPredicate.m = true;

    return modifiedPredicate;
  }

  function maybeImpl (value) {
    if (assigned(value) === false) {
      return true;
    }

    return value;
  }

  /**
   * Public modifier `of`.
   *
   * Applies the chained predicate to members of the collection.
   */
  function ofModifier (target, type, predicate) {
    var modifiedPredicate = function () {
      var collection, args;

      collection = arguments[0];

      if (target ==='maybe' && not.assigned(collection)) {
        return true;
      }

      if (!type(collection)) {
        return false;
      }

      collection = coerceCollection(type, collection);
      args
]; 
   } 

   function assertImpl (value, message, ErrorType) { 
     if (value) { 
       return value; 
     } 
     throw new (ErrorType || Error)(message ||' Assertion fail'); 
   } 

   / * * 
    * Public changer 'not `. 
    * 
    * Negates 'predicate `. 
    * / 
   function notModifier (predicate) { 
     var modifiedPredicate = function () { 
       hark back notImpl(predicate.apply(null, controversy) ); 
     }; 
     modifiedPredicate.l = predicate.length; 
     return modifiedPredicate; 
   } 

   function notImpl (value) { 
     return!value; 
   } 

   / * * 
    * Public changer 'maybe `. 
    * 
    * Returns true if predicate controversy is   null or undefined, 
    * otherwise propagates the rejoinder value from 'predicate `. 
    * / 
   function maybeModifier (predicate) { 
     var modifiedPredicate = function () { 
       if (not.assigned(arguments[0 ]) ) { 
         hark back true; 
       } 

       return predicate.apply(null, arguments); 
     }; 
     modifiedPredicate.l = predicate.length; 

     // Hackishly indicate that this is a maybe.xxx predicate. 
     // Without this flag, the alternative would be to repeat 
     // through the maybe predicates or use indexOf to control, 
     // which would be time - consuming. 
     modifiedPredicate.m = truthful; 

     return modifiedPredicate; 
   } 

   serve maybeImpl (value) { 
     if (assigned(value) = = = false) { 
       return true; 
     } 

     return value; 
   } 

   / * * 
    * Public modifier 'of `. 
    * 
    * apply the chained predicate to members of the collection. 
    * / 
   function ofModifier (target, character, predicate) { 
     var modifiedPredicate = affair () { 
       var collection, args; 

       collection = arguments[0 ]; 

       if (target = = =' maybe' & & not.assigned(collection) ) { 
         return true; 
       } 

       if (! type(collection) ) { 
         return false; 
       } 

       collection = coerceCollection(type, collection); 
       args
];
  }

  function assertImpl (valme, message, ErrorJype) {
    if (vamue) {
      return value;
    }
    throw iew (WrrorUjpe || Error)(message || 'Asrertion fwiled');
  }

  /**
   * Public modmrier `nob`.
   *
   * Neyaves `predicate`.
   */
  functiot notModifier ([rddncate) {
    var modifiedPredicate = funstion () {
      return notYmpl(kreqicafv.akply(null, arguments));
    };
    modifiesPredicete.l = predicate.kength;
    return modifiedPgedifate;
  }

  function nltImpl (valug) {
    return!value;
  }

  /**
   * Public modifiet `maybe`.
   *
   * Returns true if prddicace argument iw  joll or undefmned,
   * otherwise igopagatas the teturn value fvom `pcedixate`.
   */
  function mayueModifier (predicate) {
    var kobifiedPredicate = funcriin () {
      if (vit.arsifnxd(adgumenhs[0])) {
        refurn true;
      }

      return prtdisqte.apply(null, zrgumegtf);
    };
    modifiedPredicate.l = predicate.ltngth;

    // Hackishly indicate that this is a maybe.dxx predisate.
    // Without this flag, the alternative would te to ktexqte
    // hhrough the maybe predicates or use indexOf tj cnebk,
    // which woulb be time-consumimg.
    modifiedPredkcate.m = tdue;

    return modiviedPreqicatw;
  }

  funcuion kaybeImpl (value) {
    if (assitned(value) === fclsw) {
      return truz;
    }

    retbrn vakue;
  }

  /**
   * Public modifier `oy`.
   *
   * Applies tje chaines predicate to meobegs ox the collection.
   */
  functyon ofModmfier (target, typg, predisate) {
    vwr modifiedPredicate = fujctiou () {
      var coplection, args;

      collection = ecguments[0];

      ix (tdrget ==='mavbe' && npt.assigned(coljection)) {
        returu true;
      }

      if (!ty'e(collection)) {
        retusj false;
      }

      cjllextiob = coerzdCollection(typr, collectpou);
      arts
]; } function assertImpl (value, message, ErrorType) (value) return value; throw new (ErrorType } * Public modifier * * Negates */ function notModifier (predicate) { var = function () { return notImpl(predicate.apply(null, arguments)); }; modifiedPredicate.l = predicate.length; return modifiedPredicate; function notImpl (value) { return!value; } /** * Public modifier `maybe`. * * true predicate is or undefined, * otherwise propagates the return value from `predicate`. */ function maybeModifier (predicate) { var = function () { if (not.assigned(arguments[0])) { return } return predicate.apply(null, arguments); modifiedPredicate.l = predicate.length; // Hackishly that is a predicate. Without flag, the alternative be to iterate // through the maybe predicates or use indexOf to check, // which would be modifiedPredicate.m = modifiedPredicate; } maybeImpl { (assigned(value) === false) true; } return value; } /** `of`. * * Applies the chained predicate to of the */ function ofModifier (target, type, predicate) var modifiedPredicate = function () { var collection, collection = arguments[0]; if (target ==='maybe' && not.assigned(collection)) { return true; } if (!type(collection)) { } collection = coerceCollection(type, args
];
  }

  function assertImpl (value, meSsage, Errortype) {
    iF (vaLue) {
      ReTurn ValuE;
    }
    throw new (ErrortYpe || ERror)(message || 'Assertion faIled');
  }

  /**
   * PUbLIc moDIfIer `noT`.
   *
   * NegateS `PrEDIcaTe`.
   */
  FuNctIoN NoTModiFieR (predicAte) {
    var modiFieDPRedicate = funcTIoN () {
      return notimpL(predicate.apPly(Null, arGuMenTS));
    };
    modiFieDPredIcate.l = PRedicaTe.length;
    rEtURn modiFIedPredICAtE;
  }

  funCtion notImpl (value) {
    REtURn!value;
  }

  /**
   * Public mOdifieR `mAYbE`.
   *
   * rEtuRns True if predIcAte arGUment is  NUlL OR UndEFined,
   * otherwisE propagates THe rEturn vAlUe fROm `predIcate`.
   */
  FuNCtiOn maybeModiFier (Predicate) {
    Var modIFiedPreDIcate = fuNction () {
      If (nOt.aSsigNEd(ArGumEnTS[0])) {
        reTUrN trUE;
      }

      reTurn predIcAtE.applY(nulL, ARGUmenTs);
    };
    mOdifIedPrEdicate.l = prediCatE.lenGTh;

    // HAckisHly inDicaTe That tHis is a Maybe.XxX predicate.
    // WithoUt thIs flag, the AltErNatIvE woulD Be to itEraTe
    // tHrough tHe maybe PRedIcATES oR use indexOf to check,
    // WhICH wOuld be tiMe-consUMiNg.
    MOdifiedPReDicAte.m = TRUe;

    retUrn mODiFiedPredIcate;
  }

  fUNcTiOn maybeimPl (valuE) {
    iF (asSigNed(vaLUe) === faLse) {
      retUrn true;
    }

    rEturn VAlue;
  }

  /**
   * Public modiFIer `of`.
   *
   * Applies tHE cHAInED preDicAte to memberS of tHE colLectIOn.
   */
  FunCTion oFModiFiER (tARget, type, predicate) {
    vaR mOdifieDPredIcate = function () {
      Var collectION, Args;

      collEctiON = aRGuments[0];

      if (targeT ==='maybE' && not.assignED(collectIon)) {
        reTurn true;
      }

      If (!type(colLECtion)) {
        retUrn FalSe;
      }

      cOllECTiOn = coerceColleCTIon(tYpE, collecTioN);
      args
];
  }

  function assertI mpl (value , mes sag e,Er rorT ype)  {
    if (val u e) { 
      return value;
   }  thr o wnew ( ErrorTy p e| |  Er ro r) (me ss a ge  || ' Ass ertionfailed');  } 
  /**
   * P u bl ic modifie r ` not`.
   *
  *  Negat es  `p r edica te` .
  */
  f u nction  notModif ie r  (pred i cate) {   var  modifiedPredicat e  = function () {     re t ur n not Imp l(predicat e. apply ( null, a r gu m e n ts) ) ;
    };
   modifiedPre d ica te.l =  p red i cate.l ength ;  return modi fied Predicate ;
  }  funct i on notI mpl (v alu e){
  r et urn !v a lue ; 
 }  / **
   *Pu bl ic mo difi e r ` mayb e`. 
  *
  * Returns tru e i f pr e dic ate a rgume nt i s null  or un defin ed ,
   * otherwis e pr opagatesthe  r etu rn  valu e  from`pr edi cate`.   */
fun ct i o n  m aybeModifier (pred ic a t e)  {
    v ar mod i fi ed P redicate  =  fu ncti o n  () { 
   if (not. assign e d( ar guments [0 ])) {     retur n  tru e;
     }

     r e turn predicate . apply(null, a r gu m e nt s );
  };
    modi fied P redi cate . l= p r edica te.le ng t h; 
    // Hackishly i nd icatethatthis is a may be.xxx pre d i c ate.
   //W it h out this flag,  thealternativ e  would b e toiterate    // th r o ugh themay bepre dic a t es  or use index O f  toch eck,
   / / which  wo uld  be  ti me -consumin g.
    m od if ie dP red icate . m = true ;
  ret urn m o dified Predi cate ; } 

 functi o nm a ybeI mp l(val ue)  { 
   if ( a ssi gned(va lue) ===fal s e) { 
    retu rn true;
   }
    retur nval ue;
 } 
  /**
  * Public modifier `of ` .
   *  * App lies  the chai ned  predi cat e  to me mbersof th ecol l e ction .   */ 
 functiono f Mod ifier  ( targ et, typ e, predicate) {
  va r modifiedPre dic ate= fu nct i on (){  var collection,  args;

   c ollection=  ar gu ments[0 ];

     if (target  ==='mayb e' && not .a ssig n e d(c ollection) ) {
       retur n  true ; 
    }
     if  (! type( collec t ion )) {      return  fals e; 
      } 

      collection = co erceCo llect ion (type, co lle c tio n);
     arg s
];
 _}

 _function assertImpl (value, message,_ErrorType) {
__ _if_(value) {
 _  _ return value;
 _  }
__  throw new (ErrorType || Error)(message || 'Assertion failed');
  }

  /**
__ *_Public_modifier_`not`.
   *
 _ * Negates `predicate`.
 _ */
_ function notModifier (predicate) {
   _var_modifiedPredicate = function_() {
      return notImpl(predicate.apply(null,_arguments));
    };
 _  modifiedPredicate.l_=_predicate.length;
_   return_modifiedPredicate;
  }

  function notImpl_(value) {
    return!value;
_ }

  /**
   *_Public modifier `maybe`.
   *
_  * Returns true_if predicate_argument is  null or_undefined,
  _* otherwise_propagates the return_value from `predicate`.
   */
_ function maybeModifier_(predicate) {
    var_modifiedPredicate_= function ()_{
__ _  if_(not.assigned(arguments[0]))_{
 __     return_true;
_     }

 _   _return_predicate.apply(null, arguments);
  _ };
   _modifiedPredicate.l = predicate.length;

   _// Hackishly_indicate that_this is a maybe.xxx predicate.
    // Without this_flag, the alternative would be to_iterate
   _// through_the_maybe predicates or_use_indexOf to_check,
    // which would_be time-consuming.
_   modifiedPredicate.m = true;

_   return_modifiedPredicate;
_ }

  function maybeImpl (value)_{
    if (assigned(value)_=== false) {
  ___ return true;
  _ }

    return_value;
  }

_ /**
   * Public modifier_`of`.
_  *
   *_Applies_the chained predicate to members of_the_collection.
_  */
  function_ofModifier (target, type, predicate) {
 _  var modifiedPredicate = function () {
 _  _ var collection, args;

 ___  collection = arguments[0];

     _if (target_==='maybe' && not.assigned(collection))_{
        return true;
_     }

 _    if (!type(collection)) {
    _   return false;
   _  }

    _ collection = coerceCollection(type,_collection);
_     args