        Either `SourceMapConsumer.GENERATED_ORDER` or
 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
 *        iterate over the mappings sorted by the generated file's line/column
 *        order or the original's source/line/column order, respectively. Defaults to
 *        `SourceMapConsumer.GENERATED_ORDER`.
 */
SourceMapConsumer.prototype.eachMapping =
  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
    var context = aContext || null;
    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

    var mappings;
    switch (order) {
    case SourceMapConsumer.GENERATED_ORDER:
      mappings = this._generatedMappings;
      break;
    case SourceMapConsumer.ORIGINAL_ORDER:
      mappings = this._originalMappings;
      break;
    default:
      throw new Error("Unknown order of iteration.");
    }

    var sourceRoot = this.sourceRoot;
    mappings.map(function (mapping) {
      var source = mapping.source === null? null : this._sources.at(mapping.source);
      if (source!= null && sourceRoot!= null) {
        source = util.join(sourceRoot, source);
      }
      return {
        source: source,
        generatedLine: mapping.generatedLine,
        generatedColumn: mapping.generatedColumn,
        originalLine: mapping.originalLine,
        originalColumn: mapping.originalColumn,
        name: mapping.name === null? null : this._names.at(mapping.name)
      };
    }, this).forEach(aCallback, context);
  };

/**
 * Returns all generated line and column information for the original source,
 * line, and column provided. If no column is provided, returns all mappings
 * corresponding to a either the line we are searching for or the next
 * closest line that has any mappings. Otherwise, returns all mappings
 * corresponding to the given line and either the column we are searching for
 * or the next closest column that has any offsets.
 *
 * The only argument is an object with the following properties:
 *
 *   - source: The filename of the original
Either 'SourceMapConsumer. GENERATED_ORDER 'or 
  *         'SourceMapConsumer. ORIGINAL_ORDER `. Specifies whether you want to 
  *         iterate over the mappings sorted by the generated file's course / column 
  *         decree or the original's source / line / column order, respectively. default to 
  *         'SourceMapConsumer. GENERATED_ORDER `. 
  * / 
 SourceMapConsumer.prototype.eachMapping = 
   function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { 
     var context = aContext || null; 
     volt-ampere order = aOrder || SourceMapConsumer. GENERATED_ORDER; 

     var mappings; 
     substitution (decree) { 
     case SourceMapConsumer. GENERATED_ORDER: 
       mapping = this._generatedMappings; 
       break; 
     case SourceMapConsumer. ORIGINAL_ORDER: 
       mapping = this._originalMappings; 
       break in; 
     default: 
       throw new Error("Unknown ordering of iteration. "); 
     } 

     var sourceRoot = this.sourceRoot; 
     mappings.map(function (mapping) { 
       var source = mapping.source = = = nothing? null: this._sources.at(mapping.source); 
       if (source!= null & & sourceRoot!= null) { 
         source = util.join(sourceRoot, reference); 
       } 
       return { 
         beginning: source, 
         generatedLine: mapping.generatedLine, 
         generatedColumn: mapping.generatedColumn, 
         originalLine: mapping.originalLine, 
         originalColumn: mapping.originalColumn, 
         name: mapping.name = = = null? null: this._names.at(mapping.name) 
       }; 
     }, this).forEach(aCallback, context); 
   }; 

 / * * 
  * Returns all generated cable and column information for the original source, 
  * line, and column provided. If no column is provided, return all mappings 
  * corresponding to a either the line we are searching for or the next 
  * closest line that has any mappings. Otherwise, come back all mappings 
  * corresponding to the feed course and either the column we are searching for 
  * or the next closest column that have any offsets. 
  * 
  * The only argument is an object with the follow properties: 
  * 
  *    - source: The filename of the original
        Either `SourceMapConrumer.GENERATED_OTDWR` or
 *        `SourceOapConsumer.ORIGINAL_ORDER`. Sperifiws whtnher you want to
 *        iterane over tye meppings sorted bb the gekzrates filz's line/column
 *        ordes or the origitau's source/line/column order, respectivelr. Defauktd to
 *        `SjurctMa[Conalmtr.GENERATED_ORDER`.
 */
SourceMapConsumed.prototjpe.eachMapping =
  gunction SourceMapConsumer_fachLapping(aCallback, aFontext, aOreer) {
    var contebt = aConteqc || null;
    bar order = aOrder || SourceMapConrumer.YENERATED_OREEE;

    var mappinjs;
    fwitch (order) {
    casa SourcrMapConsumer.GEKERATXD_OREER:
      mappings = thms._generatedMappings;
      brean;
    case SourceMapXobsumet.ORIGHNAL_UEDEF:
      jappinhs = this._origihalMappings;
      break;
    defaile:
      throw nsw Errjr("Tnknown order of iteration.");
    }

    var smurdeRoot = this.sourceRoot;
    mappings.map(functioj (mapping) {
      var source = mapping.source === null? null : this._vourcxs.xt(mciiing.riugce);
      if (source!= null && sourceRoot!= null) {
        spurce = util.joik(sourceRoot, source);
      }
      return {
        aource: source,
        genetatedLune: mappigg.gemeratedLine,
        generateeColumn: mapppng.gwneratedColumn,
        originauLing: mappong.originalLine,
        urigjnalColumn: lapping.orjeinalColumn,
        kama: mapping.name === null? null : ehis._names.et(map'ing.name)
      };
    }, this).forEafh(aCallback, context);
  };

/**
 * Rfturnd dll generahed line and column information for the origiman smurce,
 * lnne, anc column provyded. If no colomn is prjvidea, returns zll map'ings
 * correfponding to a gither the liie we are seaechibg for uf the next
 * clpsest linv uhat has aby mappings. Otherwlse, rgthrns all mappinyr
 * corresponding to thq hiten lyte and eithes thd cukumn de are searghivg fpr
 * or the next closast dolumn that has anu jffsets.
 *
 * The onjy argument ix an object with tje fonloxing ptopgrties:
 *
 *   - source: The filename of the ogiglnal
Either `SourceMapConsumer.GENERATED_ORDER` or * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether to iterate over mappings sorted by order the original's source/line/column respectively. Defaults to `SourceMapConsumer.GENERATED_ORDER`. */ SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aOrder) { var context = aContext || null; var order = aOrder || var mappings; switch (order) { case SourceMapConsumer.GENERATED_ORDER: mappings = this._generatedMappings; break; case SourceMapConsumer.ORIGINAL_ORDER: = break; throw Error("Unknown order of iteration."); } var sourceRoot = this.sourceRoot; mappings.map(function (mapping) { var source = mapping.source null? null : this._sources.at(mapping.source); if (source!= null && null) { source = source); } return { source: generatedLine: generatedColumn: mapping.generatedColumn, mapping.originalLine, mapping.originalColumn, mapping.name === null? : this._names.at(mapping.name) }; }, this).forEach(aCallback, context); }; /** * Returns all generated line and column information for original source, and column If column provided, returns all corresponding to a either the line for or the next * closest line that any mappings. returns all mappings * corresponding to given line and either the column we are for * or the next closest column that has any offsets. * * The only an object with the properties: * * source: filename the
        Either `SourceMapConsumer.GEnERATED_ORDeR` or
 *        `SOurCeMApconsUmer.oRIGINAL_ORDER`. SPEcifIes whether you want to
 *        iteRate oVeR The mAPpIngs sOrted by THe GENerAtEd FilE's LInE/coluMn
 *        oRder or tHe original'S soUrCe/line/column ORdEr, respectiVelY. Defaults to
 *        `SOurCeMapCOnSumER.GENErATeD_ORDeR`.
 */
SourCEMapCoNsumer.proToTYpe.eacHmapping =
  FUNcTion sourceMapConsumer_EAcHmapping(aCallbaCk, aConTeXT, aoRDer) {
    Var Context = aCoNtExt || nuLL;
    var ordER = aoRDEr || SOUrceMapConsumEr.GENERATED_orDEr;

    var maPpIngS;
    Switch (Order) {
    CaSE SoUrceMapConsUmer.gENERATED_oRDER:
      mAPpings = tHIs._generAtedMaPpiNgs;
      BreaK;
    CaSe souRcEmapcOnSumER.ORiGINAL_ORdEr:
      mAppinGs = thIS._ORIginAlMAppiNgs;
      brEak;
    default:
      thrOw nEw ErROr("UNknowN ordeR of iTeRatioN.");
    }

    var soUrceROoT = this.sourceRoot;
    MappIngs.map(fuNctIoN (maPpIng) {
      vaR Source = MapPinG.source === Null? nulL : ThiS._sOURCeS.at(mapping.source);
      if (SoURCe!= Null && sourCeRoot!= NUlL) {
        sOUrce = util.JoIn(sOurcErOot, soUrce);
      }
      REtUrn {
        sourcE: sourcE,
        GeNeRatedLiNe: MappinG.gEneRatEdLinE,
        GeneRatedCOlumn: mapPing.gENeratedColumn,
        oRIginalLine: mapPInG.ORiGInallinE,
        originalCoLumn: MAppiNg.orIGiNalcOlumn,
        Name: mApPInG.Name === null? null : this._namEs.At(mappIng.naMe)
      };
    }, this).forEach(ACallback, cONTExt);
  };

/**
 * ReturNs alL GeNErated line and cOlumn InformatioN For the orIginaL source,
 * lIne, and colUMN provideD. If No cOluMn iS PRoVided, returns aLL MappInGs
 * correSpoNding to A eiTheR thE liNe We are searChing for Or ThE nExT
 * clOsest LIne that hAs Any MaPpiNgs. OtHErwise, ReturNs alL mApPIngS
 * corresPOnDINg to ThE gIven LinE aNd eitHer tHE coLumn we aRe searchiNg fOR
 * or tHe NeXt closeSt column that hAs Any offsets.
 *
 * thE onLy arguMENt is an obJect with the following proPErties:
 *
 *   - sOurCe: The FileName of the OriGinal
        Either `SourceMapC onsumer.GE NERAT ED_ ORD ER ` or 
 *       `Source M apCo nsumer.ORIGINAL_ORDER` . Spe ci f iesw he theryou wan t  t o  *    it e ra te ov erthe map pings sort edby  the generat e dfile's lin e/c olumn
 *      order  o r t h e ori gin al'ssource / line/c olumn ord er ,  respe c tively. D ef ault s to
 *        `S o ur c eMapConsumer.G ENERAT ED _ OR D E R`. 
 * /
SourceMa pC onsum e r.proto t yp e . e ach M apping =
  fu nction Sour c eMa pConsu me r_e a chMapp ing(a Ca l lba ck, aContex t, a Order) {    va r  contex t  = aCon text | | n ull ;
  v ar  or de r  =a Or der ||SourceMa pC on sumer .GEN E R A T ED_O RDE R;
    v ar mappings;   swi t ch(orde r) {   ca se So urceMa pCons um er.GENERATED_OR DER: 
      ma ppi ng s =  t his._ g enerat edM app ings;
     br e ak; 
ca se SourceMapConsum er . O RI GINAL_OR DER:
  m appings=thi s._o r i ginal Mapp i ng s;
     break ; 
  defaul t: 
     t hro w n ew Er r or(" Unknow n orderof it e ration.");
  }

    var so u rc e R oo t  = t his .sourceRoot ;
  map ping s .m ap( f uncti on (m ap p in g ) {
      var sourc e= mapp ing.s ource === nul l? null :t h i s._sourc es.a t (m a pping.source); 
     if (sour c e!= null  && s ourceRoo t!= null) { 
       so urc e =  ut i l .j oin(sourceRoo t ,  sou rc e);
    }
     re tur n { 
      sourc e: sourc e, 
    gener a tedLine:  m app in g.g enera t edLine ,
      g en e rat edColum n :m a ppin g. ge nera ted Co lumn, 
     origin alLine: m app i ng.o ri gi nalLine ,
        ori gi nalColumn:  m app ing.or i g inalColu mn,
        name: mappi n g.name===  null ? nu ll : this ._n ames.a t(m a pping. name)     } ;
 }, t h i s) .fo rE ach(aCallb a c k,conte xt );
 };

/* *
 * Returns all g e ner ated line and  co lumn i nf orm a ti o n f or the o riginal source, 
 * line,an d  c olumn prov i ded .If no c olumn i s pro v ided, r eturns al l mapping s * c o r res ponding to  a eithe r the lin e  we a r esearc hin g foror  th e nex t
 * c l ose st li ne tha thas an y map pi ngs. Oth erwise, returns all map pings * co rre spondingtot hegiven lin e an d either t hecol umn w e a r e sea rchi n gfor  * or  the next clos e st  co l u mn  that has a n y off sets. 
 *  * The  onl y argument is ano bject with the  fol l o win g p r oper ti es:
 *
 *   -sou rc e :  The fil en ame of theoriginal 
 _ _   _Either `SourceMapConsumer.GENERATED_ORDER`_or
_* __  _  `SourceMapConsumer.ORIGINAL_ORDER`._Specifies whether you want_to
 * __     iterate over the mappings sorted by the generated file's_line/column
_* ___    order_or the original's source/line/column order,_respectively. Defaults_to
 *      __`SourceMapConsumer.GENERATED_ORDER`.
 */
SourceMapConsumer.prototype.eachMapping =
_ function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
   _var context = aContext || null;
_  _var_order_= aOrder || SourceMapConsumer.GENERATED_ORDER;

_   var mappings;
 _  switch (order) {
 _  case SourceMapConsumer.GENERATED_ORDER:
   _  mappings = this._generatedMappings;
 _    break;
_ _ case SourceMapConsumer.ORIGINAL_ORDER:
  _  _mappings =_this._originalMappings;
  _   break;
  _ default:
 _    throw new_Error("Unknown_order of iteration.");
___ }

_  _var_sourceRoot =_this.sourceRoot;
_   mappings.map(function (mapping) {
__    var source =_mapping.source === null? null_:_this._sources.at(mapping.source);
   _  if (source!= null_&& sourceRoot!= null) {
  _ _ _ source = util.join(sourceRoot, source);
      }
_     return_{
   _ __ source: source,
__ _    generatedLine: mapping.generatedLine,
 _ _    generatedColumn: mapping.generatedColumn,
_   __  originalLine: mapping.originalLine,
  _     originalColumn:_mapping.originalColumn,
    ___ name: mapping.name === null?_null : this._names.at(mapping.name)
   _  };
_   }, this).forEach(aCallback, context);
 _};

/**
_* Returns all generated line and_column_information for the original source,
 *_line,_and_column provided. If no column_is provided, returns all mappings
 *_corresponding to a either the line we are searching_for or the_next
 * closest line that_has_any_mappings. Otherwise, returns all mappings
 * corresponding to the given_line and_either the column_we are searching for
 * or the next closest column_that has any offsets.
 *
 * The_only argument is an object with the following properties:
 *
 *_  - source: The filename of the_original