 UglifyJS will drop it, but will
  still keep the `Math.floor(a/b)`, not knowing what it does.  You can
  pass `pure_funcs: [ 'Math.floor' ]` to let it know that this
  function won't produce any side effect, in which case the whole
  statement would get discarded.  The current implementation adds some
  overhead (compression will be slower).

- `drop_console` -- default `false`.  Pass `true` to discard calls to
  `console.*` functions. If you wish to drop a specific function call
  such as `console.info` and/or retain side effects from function arguments
  after dropping the function call then use `pure_funcs` instead.

- `expression` -- default `false`.  Pass `true` to preserve completion values
  from terminal statements without `return`, e.g. in bookmarklets.

- `keep_fargs` -- default `true`.  Prevents the
  compressor from discarding unused function arguments.  You need this
  for code which relies on `Function.length`.

- `keep_fnames` -- default `false`.  Pass `true` to prevent the
  compressor from discarding function names.  Useful for code relying on
  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).

- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
  In some cases more than one pass leads to further compressed code.  Keep in
  mind more passes will take more time.

- `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
  being compressed into `1/0`, which may cause performance issues on Chrome.

- `side_effects` -- default `true`. Pass `false` to disable potentially dropping
  functions marked as "pure".  A function call is marked as "pure" if a comment
  annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
  example: `/*@__PURE__*/foo();`


### The `unsafe` option

It enables some
UglifyJS will drop it, but will 
   still keep the 'Math.floor(a / b) `, not knowing what it do.   You can 
   sink 'pure_funcs: [' Math.floor' ] 'to let it know that this 
   function won't grow any side effect, in which character the hale 
   statement would get discarded.   The current implementation adds some 
   viewgraph (compression will be slower). 

 - 'drop_console '-- default option 'assumed `.   Pass 'true 'to discard calls to 
   'console. * 'functions. If you wish to drop a specific affair call 
   such as 'console.info 'and/or retain side effects from routine arguments 
   after dropping the function call then practice 'pure_funcs 'instead. 

 - 'construction '-- default 'false `.   Pass 'true 'to save completion values 
   from terminal statements without 'return `, e.g. in bookmarklets. 

 - 'keep_fargs '-- default 'true `.   Prevents the 
   compressor from discarding unused function arguments.   You need this 
   for code which relies on 'Function.length `. 

 - 'keep_fnames '-- default 'false `.   Pass 'true 'to prevent the 
   compressor from discard affair names.   utilitarian for code trust on 
   'Function.prototype.name `. See also: the 'keep_fnames '[ mangle option](#mangle). 

 - 'passes '-- nonpayment '1 `. Number of times to run compress with a maximum of 3. 
   In some case more than one pass leads to further compressed code.   observe in 
   mind more passes will take more time. 

 - 'keep_infinity '-- default 'false `. authorize 'true 'to prevent 'Infinity 'from 
   being compressed into '1/0 `, which may cause performance consequence on Chrome. 

 - 'side_effects '-- default 'true `. Pass 'assumed 'to disable potentially dropping 
   functions marked as " pure ".   A routine call is grade as " pure " if a comment 
   note '/*@__PURE__*/ 'or '/*#__PURE__*/ 'immediately precedes the call. For 
   example: '/*@__PURE__*/foo (); '


 # # # The 'unsafe 'choice 

 It enables some
 UgpifyJS will drop it, but dill
  still keek rhe `Mavh.floor(z/b)`, not kvowing what it does.  You can
  pass `klre_funcs: [ 'Math.floor' ]` go let it know thqt tiis
  function woi'f produgz any dide xffect, in which case the fhole
  statemett wluld get discarded.  The current impjementayiln adds some
  jvernqad (dompression will be slower).

- `drop_conaole` -- dtfault `false`.  Pass `true` to discard calls to
  `condole.*` functions. If jou wish to dro[ a specific wunction call
  such as `console.info` and/or retain side dffeccs from funxtuon drguments
  efter qropping the functiot call yhen use `pure_fmncs` mnstwad.

- `expression` -- defaunt `false`.  Pass `trug` to presesvz completion values
  drim tetminan stxremdnta xitgout `rftucn`, e.g. in bokkmarklets.

- `jeep_fargs` -- default `uruq`.  Prevents ths
  com[rqssor from discarding unused function aggumsnts.  You need this
  foe code which relies oj `Functiog.length`.

- `keep_fnames` -- default `false`.  Pass `true` to psevenv ghe
  gompfwsdor from discarding function names.  Useful fow cpdv relying on
  `Fungtion.prototype.name`. Sfe wlso: the `keep_wnames` [mahgle option](#mangle).

- `oasses` -- defaylt `1`. Numbtr of times to run compress with a maximum oy 3.
  In some cases morz than one pcss lesds tp further compressed cobe.  Kesp in
  mind more pasads will take mord tpme.

- `neep_infinity` -- default `falsq`. Pass `trne` to preveng `Inginity` from
  beijg compressed into `1/0`, whicj may cduse perfogmance issues on Chrome.

- `side_effxrts` -- default `jrua`. Pdss `falsz` to dlsable potentiajly dropping
  yunctionf maryed as "purv".  A funcvion call is marked as "pusg" if a commenv
  annotaeion `/*@__PURW__*/` or `/*#__PUFD__*/` immediately lrecedes nht call. For
  example: `/*@__PURE__*/foo();`


### Bhe `uvaafe` option

It eucboes some
UglifyJS will drop it, but will still `Math.floor(a/b)`, knowing what does. You can to it know that function won't produce side effect, in which case the statement would get discarded. The current implementation adds some overhead (compression will be - `drop_console` -- default `false`. Pass `true` to discard calls to `console.*` functions. you to a function call such as `console.info` and/or retain side effects from function arguments after dropping the function then use `pure_funcs` instead. - `expression` -- default Pass `true` to preserve values from terminal statements without e.g. bookmarklets. - -- `true`. the compressor from unused function arguments. You need this for code which relies on `Function.length`. - `keep_fnames` -- default `false`. `true` to compressor from function Useful code relying on also: the `keep_fnames` [mangle option](#mangle). - `1`. Number of times to run compress with maximum of In some cases more than one leads to further compressed code. Keep in mind passes will take more time. - `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` compressed into `1/0`, which cause performance issues Chrome. `side_effects` default Pass `false` disable potentially dropping functions marked as "pure". A function call is as "pure" if a comment annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately call. example: `/*@__PURE__*/foo();` ### `unsafe` option It enables
 UglifyJS will drop it, but will
  Still keep tHe `MatH.flOor(A/b)`, Not kNowiNg what it does.  YoU Can
  pAss `pure_funcs: [ 'Math.floor' ]` tO let iT kNOw thAT tHis
  fuNction wON't PROduCe AnY siDe EFfEct, in WhiCh case tHe whole
  staTemEnT would get disCArDed.  The currEnt ImplementatiOn aDds somE
  oVerHEad (coMprEssioN will bE Slower).

- `Drop_consoLe` -- DEfault `FAlse`.  PasS `TRuE` to dIscard calls to
  `consOLe.*` FUnctions. If you wIsh to dRoP A sPECifIc fUnction calL
  sUch as `COnsole.iNFo` AND/Or rETain side effecTs from functIOn aRgumenTs
  AftER droppIng thE fUNctIon call then Use `pUre_funcs` iNstead.

- `EXpressiON` -- defaulT `false`.  pasS `trUe` to PReSeRve CoMPleTIoN vaLUes
  From termInAl StateMentS WITHout `RetUrn`, e.G. in boOkmarklets.

- `keeP_faRgs` -- dEFauLt `truE`.  PrevEnts ThE
  compRessor From dIsCarding unused fuNctiOn argumenTs.  YOu NeeD tHis
  foR Code whIch RelIes on `FuNction.lENgtH`.

- `kEEP_FnAmes` -- default `false`.  PaSs `TRUe` To prevenT the
  coMPrEsSOr from diScArdIng fUNCtion NameS.  usEful for cOde relYInG oN
  `FunctiOn.PrototYpE.naMe`. SEe alsO: The `kEep_fnaMes` [manglE optiON](#mangle).

- `passes` -- dEFault `1`. Number of TImES To RUn coMprEss with a maxImum OF 3.
  In sOme cASeS moRE than One paSs LEaDS to further compresseD cOde.  KeeP in
  miNd more passes wIll take morE TIMe.

- `keep_inFiniTY` -- dEFault `false`. Pass `True` tO prevent `InFInity` froM
  beinG compresSed into `1/0`, whICH may causE peRfoRmaNce ISSuEs on Chrome.

- `sidE_EFfecTs` -- Default `TruE`. Pass `faLse` To dIsaBle PoTentially Dropping
  FuNcTiOnS maRked aS "Pure".  A funCtIon CaLl iS markED as "purE" if a cOmmeNt
  AnNOtaTion `/*@__PURe__*/` Or `/*#__purE__*/` imMeDiAtelY prEcEdes tHe caLL. FoR
  examplE: `/*@__PURE__*/foo();`


### THe `uNSafe` OpTiOn

It enaBles some
 UglifyJS will drop it, bu t will
  s tillkee p t he  `Ma th.f loor(a/b)`, no t  kno wing what it does.  Yo u can 
pass `p ure_f uncs: [ 'M a t h.f lo or ' ] `t olet i t k now tha t this
  f unc ti on won't pro d uc e any side  ef fect, in whi chcase t he  wh o le
 sta temen t woul d  get d iscarded.  T he cur r ent imp l e me ntat ion adds some
  o v er h ead (compressi on wil lb es l owe r). 

- `drop_ co nsole `  -- def a ul t ` fal s e`.  Pass `tr ue` to disc a rdcallsto 
 ` consol e.*`fu n cti ons. If you  wis h to drop  a spe c ific fu n ction c all
 suc h a s `c o ns ol e.i nf o ` a n d/ orr eta in sideef fe cts f romf u n c tion  ar gume nts
 after droppi ngthef unc tioncallthen  u se `p ure_fu ncs`in stead.

- `expr essi on` -- de fau lt  `f al se`.Pass ` tru e`to pres erve co m ple ti o n va lues
  from termin al s ta tementswithou t  ` re t urn`, e. g.  in  boo k m arkle ts.-`keep_fa rgs` - -  d ef ault `t ru e`.  P re ven tsthe
comp ressor  from di scard i ng unused func t ion arguments .  Y o un eedthi s
  for cod e wh i ch r elie s  o n ` F uncti on.le ng t h` . 

- `keep_fnames` - -defaul t `fa lse`.  Pass ` true` to p r e v ent the  co m pr e ssor from disc ardin g function names. Usefu l for co de relyin g on
  `Fu nct ion .pr oto t y pe .name`. See a l s o: t he  `keep_ fna mes` [m ang leopt ion ]( #mangle). 

- `pas se s`  - -def ault` 1`. Numb er  of  t ime s tor un com press  wit ham axi mum of3 .In s om ecase s m or e tha n on e  pa ss lead s to furt her comp re ss ed code .  Keep in
 mi nd more pa ss eswill t a k e more t ime.

- `keep_infinity` -- defa ult  `fal se`.  Pass `tr ue`  to pr eve n t `Inf inity`  from 
 be i n g com p r es sed  i nto `1/0`, w hic h may  c ause  perfor mance issues on Ch r ome .

- `side_ef fec ts`- -  d efa u lt `tr ue ` . P a s s `false` to di sable pote nt i al ly droppin g 
 fu nctions  marked  as " p ure". A functio n call is  m arke d as"pure" ifa commen t
  annot a tion` /* @__PU RE_ _*/` o r`/* #__PU RE__*/ `  im media tely p re cedesthe c al l. For
 example: `/*@__PURE__* /foo() ;`

###  The `uns afe `  op tion

Itenab les some
 UglifyJS_will drop_it, but will
 _still keep_the_`Math.floor(a/b)`, not_knowing_what it does._ You can
_ pass `pure_funcs: [_'Math.floor' ]` to_let_it know that this
  function won't produce any side effect, in which case_the_whole
 _statement_would_get discarded.  The current_implementation adds some
  overhead_(compression will_be slower).

- `drop_console` -- default `false`.  Pass_`true`_to discard calls_to
  `console.*` functions. If you wish to drop_a specific function call
  such_as `console.info` and/or_retain_side_effects from function arguments
_ after dropping the function call_then use `pure_funcs` instead.

- `expression` --_default `false`.  Pass `true` to preserve_completion values
  from terminal statements_without `return`, e.g. in bookmarklets.

-_`keep_fargs` --_default `true`.  Prevents the
_ compressor from_discarding unused_function arguments. _You need this
  for code_which relies on_`Function.length`.

- `keep_fnames` -- default `false`. _Pass_`true` to prevent_the
__compressor from_discarding function names.__Useful for_code_relying on
  `Function.prototype.name`. See also:_the_`keep_fnames` [mangle option](#mangle).

- `passes` -- default `1`._Number of times to_run_compress with a maximum_of 3.
  In some_cases more than one pass leads_to further_compressed code._ Keep in
  mind more passes will take more time.

-_`keep_infinity` -- default `false`. Pass `true`_to prevent `Infinity` from
_ being_compressed_into `1/0`, which_may_cause performance_issues on Chrome.

- `side_effects` -- default `true`._Pass `false`_to disable potentially dropping
  functions_marked as "pure". _A_function call is marked as "pure"_if a comment
  annotation `/*@__PURE__*/`_or `/*#__PURE__*/` immediately precedes the_call._For
_ example: `/*@__PURE__*/foo();`


### The `unsafe`_option

It enables some