.config/coc/extensions/node_modules/coc-prettier/node_modules/source-map/dist/source-map.js

   1 (function webpackUniversalModuleDefinition(root, factory) {
   2         if(typeof exports === 'object' && typeof module === 'object')
   3                 module.exports = factory();
   4         else if(typeof define === 'function' && define.amd)
   5                 define([], factory);
   6         else if(typeof exports === 'object')
   7                 exports["sourceMap"] = factory();
   8         else
   9                 root["sourceMap"] = factory();
  10 })(this, function() {
  11 return /******/ (function(modules) { // webpackBootstrap
  12 /******/        // The module cache
  13 /******/        var installedModules = {};
  14
  15 /******/        // The require function
  16 /******/        function __webpack_require__(moduleId) {
  17
  18 /******/                // Check if module is in cache
  19 /******/                if(installedModules[moduleId])
  20 /******/                        return installedModules[moduleId].exports;
  21
  22 /******/                // Create a new module (and put it into the cache)
  23 /******/                var module = installedModules[moduleId] = {
  24 /******/                        exports: {},
  25 /******/                        id: moduleId,
  26 /******/                        loaded: false
  27 /******/                };
  28
  29 /******/                // Execute the module function
  30 /******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  31
  32 /******/                // Flag the module as loaded
  33 /******/                module.loaded = true;
  34
  35 /******/                // Return the exports of the module
  36 /******/                return module.exports;
  37 /******/        }
  38
  39
  40 /******/        // expose the modules object (__webpack_modules__)
  41 /******/        __webpack_require__.m = modules;
  42
  43 /******/        // expose the module cache
  44 /******/        __webpack_require__.c = installedModules;
  45
  46 /******/        // __webpack_public_path__
  47 /******/        __webpack_require__.p = "";
  48
  49 /******/        // Load entry module and return exports
  50 /******/        return __webpack_require__(0);
  51 /******/ })
  52 /************************************************************************/
  53 /******/ ([
  54 /* 0 */
  55 /***/ (function(module, exports, __webpack_require__) {
  56
  57         /*
  58          * Copyright 2009-2011 Mozilla Foundation and contributors
  59          * Licensed under the New BSD license. See LICENSE.txt or:
  60          * http://opensource.org/licenses/BSD-3-Clause
  61          */
  62         exports.SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;
  63         exports.SourceMapConsumer = __webpack_require__(7).SourceMapConsumer;
  64         exports.SourceNode = __webpack_require__(10).SourceNode;
  65
  66
  67 /***/ }),
  68 /* 1 */
  69 /***/ (function(module, exports, __webpack_require__) {
  70
  71         /* -*- Mode: js; js-indent-level: 2; -*- */
  72         /*
  73          * Copyright 2011 Mozilla Foundation and contributors
  74          * Licensed under the New BSD license. See LICENSE or:
  75          * http://opensource.org/licenses/BSD-3-Clause
  76          */
  77
  78         var base64VLQ = __webpack_require__(2);
  79         var util = __webpack_require__(4);
  80         var ArraySet = __webpack_require__(5).ArraySet;
  81         var MappingList = __webpack_require__(6).MappingList;
  82
  83         /**
  84          * An instance of the SourceMapGenerator represents a source map which is
  85          * being built incrementally. You may pass an object with the following
  86          * properties:
  87          *
  88          *   - file: The filename of the generated source.
  89          *   - sourceRoot: A root for all relative URLs in this source map.
  90          */
  91         function SourceMapGenerator(aArgs) {
  92           if (!aArgs) {
  93             aArgs = {};
  94           }
  95           this._file = util.getArg(aArgs, 'file', null);
  96           this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
  97           this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
  98           this._sources = new ArraySet();
  99           this._names = new ArraySet();
 100           this._mappings = new MappingList();
 101           this._sourcesContents = null;
 102         }
 103
 104         SourceMapGenerator.prototype._version = 3;
 105
 106         /**
 107          * Creates a new SourceMapGenerator based on a SourceMapConsumer
 108          *
 109          * @param aSourceMapConsumer The SourceMap.
 110          */
 111         SourceMapGenerator.fromSourceMap =
 112           function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
 113             var sourceRoot = aSourceMapConsumer.sourceRoot;
 114             var generator = new SourceMapGenerator({
 115               file: aSourceMapConsumer.file,
 116               sourceRoot: sourceRoot
 117             });
 118             aSourceMapConsumer.eachMapping(function (mapping) {
 119               var newMapping = {
 120                 generated: {
 121                   line: mapping.generatedLine,
 122                   column: mapping.generatedColumn
 123                 }
 124               };
 125
 126               if (mapping.source != null) {
 127                 newMapping.source = mapping.source;
 128                 if (sourceRoot != null) {
 129                   newMapping.source = util.relative(sourceRoot, newMapping.source);
 130                 }
 131
 132                 newMapping.original = {
 133                   line: mapping.originalLine,
 134                   column: mapping.originalColumn
 135                 };
 136
 137                 if (mapping.name != null) {
 138                   newMapping.name = mapping.name;
 139                 }
 140               }
 141
 142               generator.addMapping(newMapping);
 143             });
 144             aSourceMapConsumer.sources.forEach(function (sourceFile) {
 145               var sourceRelative = sourceFile;
 146               if (sourceRoot !== null) {
 147                 sourceRelative = util.relative(sourceRoot, sourceFile);
 148               }
 149
 150               if (!generator._sources.has(sourceRelative)) {
 151                 generator._sources.add(sourceRelative);
 152               }
 153
 154               var content = aSourceMapConsumer.sourceContentFor(sourceFile);
 155               if (content != null) {
 156                 generator.setSourceContent(sourceFile, content);
 157               }
 158             });
 159             return generator;
 160           };
 161
 162         /**
 163          * Add a single mapping from original source line and column to the generated
 164          * source's line and column for this source map being created. The mapping
 165          * object should have the following properties:
 166          *
 167          *   - generated: An object with the generated line and column positions.
 168          *   - original: An object with the original line and column positions.
 169          *   - source: The original source file (relative to the sourceRoot).
 170          *   - name: An optional original token name for this mapping.
 171          */
 172         SourceMapGenerator.prototype.addMapping =
 173           function SourceMapGenerator_addMapping(aArgs) {
 174             var generated = util.getArg(aArgs, 'generated');
 175             var original = util.getArg(aArgs, 'original', null);
 176             var source = util.getArg(aArgs, 'source', null);
 177             var name = util.getArg(aArgs, 'name', null);
 178
 179             if (!this._skipValidation) {
 180               this._validateMapping(generated, original, source, name);
 181             }
 182
 183             if (source != null) {
 184               source = String(source);
 185               if (!this._sources.has(source)) {
 186                 this._sources.add(source);
 187               }
 188             }
 189
 190             if (name != null) {
 191               name = String(name);
 192               if (!this._names.has(name)) {
 193                 this._names.add(name);
 194               }
 195             }
 196
 197             this._mappings.add({
 198               generatedLine: generated.line,
 199               generatedColumn: generated.column,
 200               originalLine: original != null && original.line,
 201               originalColumn: original != null && original.column,
 202               source: source,
 203               name: name
 204             });
 205           };
 206
 207         /**
 208          * Set the source content for a source file.
 209          */
 210         SourceMapGenerator.prototype.setSourceContent =
 211           function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
 212             var source = aSourceFile;
 213             if (this._sourceRoot != null) {
 214               source = util.relative(this._sourceRoot, source);
 215             }
 216
 217             if (aSourceContent != null) {
 218               // Add the source content to the _sourcesContents map.
 219               // Create a new _sourcesContents map if the property is null.
 220               if (!this._sourcesContents) {
 221                 this._sourcesContents = Object.create(null);
 222               }
 223               this._sourcesContents[util.toSetString(source)] = aSourceContent;
 224             } else if (this._sourcesContents) {
 225               // Remove the source file from the _sourcesContents map.
 226               // If the _sourcesContents map is empty, set the property to null.
 227               delete this._sourcesContents[util.toSetString(source)];
 228               if (Object.keys(this._sourcesContents).length === 0) {
 229                 this._sourcesContents = null;
 230               }
 231             }
 232           };
 233
 234         /**
 235          * Applies the mappings of a sub-source-map for a specific source file to the
 236          * source map being generated. Each mapping to the supplied source file is
 237          * rewritten using the supplied source map. Note: The resolution for the
 238          * resulting mappings is the minimium of this map and the supplied map.
 239          *
 240          * @param aSourceMapConsumer The source map to be applied.
 241          * @param aSourceFile Optional. The filename of the source file.
 242          *        If omitted, SourceMapConsumer's file property will be used.
 243          * @param aSourceMapPath Optional. The dirname of the path to the source map
 244          *        to be applied. If relative, it is relative to the SourceMapConsumer.
 245          *        This parameter is needed when the two source maps aren't in the same
 246          *        directory, and the source map to be applied contains relative source
 247          *        paths. If so, those relative source paths need to be rewritten
 248          *        relative to the SourceMapGenerator.
 249          */
 250         SourceMapGenerator.prototype.applySourceMap =
 251           function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
 252             var sourceFile = aSourceFile;
 253             // If aSourceFile is omitted, we will use the file property of the SourceMap
 254             if (aSourceFile == null) {
 255               if (aSourceMapConsumer.file == null) {
 256                 throw new Error(
 257                   'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
 258                   'or the source map\'s "file" property. Both were omitted.'
 259                 );
 260               }
 261               sourceFile = aSourceMapConsumer.file;
 262             }
 263             var sourceRoot = this._sourceRoot;
 264             // Make "sourceFile" relative if an absolute Url is passed.
 265             if (sourceRoot != null) {
 266               sourceFile = util.relative(sourceRoot, sourceFile);
 267             }
 268             // Applying the SourceMap can add and remove items from the sources and
 269             // the names array.
 270             var newSources = new ArraySet();
 271             var newNames = new ArraySet();
 272
 273             // Find mappings for the "sourceFile"
 274             this._mappings.unsortedForEach(function (mapping) {
 275               if (mapping.source === sourceFile && mapping.originalLine != null) {
 276                 // Check if it can be mapped by the source map, then update the mapping.
 277                 var original = aSourceMapConsumer.originalPositionFor({
 278                   line: mapping.originalLine,
 279                   column: mapping.originalColumn
 280                 });
 281                 if (original.source != null) {
 282                   // Copy mapping
 283                   mapping.source = original.source;
 284                   if (aSourceMapPath != null) {
 285                     mapping.source = util.join(aSourceMapPath, mapping.source)
 286                   }
 287                   if (sourceRoot != null) {
 288                     mapping.source = util.relative(sourceRoot, mapping.source);
 289                   }
 290                   mapping.originalLine = original.line;
 291                   mapping.originalColumn = original.column;
 292                   if (original.name != null) {
 293                     mapping.name = original.name;
 294                   }
 295                 }
 296               }
 297
 298               var source = mapping.source;
 299               if (source != null && !newSources.has(source)) {
 300                 newSources.add(source);
 301               }
 302
 303               var name = mapping.name;
 304               if (name != null && !newNames.has(name)) {
 305                 newNames.add(name);
 306               }
 307
 308             }, this);
 309             this._sources = newSources;
 310             this._names = newNames;
 311
 312             // Copy sourcesContents of applied map.
 313             aSourceMapConsumer.sources.forEach(function (sourceFile) {
 314               var content = aSourceMapConsumer.sourceContentFor(sourceFile);
 315               if (content != null) {
 316                 if (aSourceMapPath != null) {
 317                   sourceFile = util.join(aSourceMapPath, sourceFile);
 318                 }
 319                 if (sourceRoot != null) {
 320                   sourceFile = util.relative(sourceRoot, sourceFile);
 321                 }
 322                 this.setSourceContent(sourceFile, content);
 323               }
 324             }, this);
 325           };
 326
 327         /**
 328          * A mapping can have one of the three levels of data:
 329          *
 330          *   1. Just the generated position.
 331          *   2. The Generated position, original position, and original source.
 332          *   3. Generated and original position, original source, as well as a name
 333          *      token.
 334          *
 335          * To maintain consistency, we validate that any new mapping being added falls
 336          * in to one of these categories.
 337          */
 338         SourceMapGenerator.prototype._validateMapping =
 339           function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
 340                                                       aName) {
 341             // When aOriginal is truthy but has empty values for .line and .column,
 342             // it is most likely a programmer error. In this case we throw a very
 343             // specific error message to try to guide them the right way.
 344             // For example: https://github.com/Polymer/polymer-bundler/pull/519
 345             if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
 346                 throw new Error(
 347                     'original.line and original.column are not numbers -- you probably meant to omit ' +
 348                     'the original mapping entirely and only map the generated position. If so, pass ' +
 349                     'null for the original mapping instead of an object with empty or null values.'
 350                 );
 351             }
 352
 353             if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
 354                 && aGenerated.line > 0 && aGenerated.column >= 0
 355                 && !aOriginal && !aSource && !aName) {
 356               // Case 1.
 357               return;
 358             }
 359             else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
 360                      && aOriginal && 'line' in aOriginal && 'column' in aOriginal
 361                      && aGenerated.line > 0 && aGenerated.column >= 0
 362                      && aOriginal.line > 0 && aOriginal.column >= 0
 363                      && aSource) {
 364               // Cases 2 and 3.
 365               return;
 366             }
 367             else {
 368               throw new Error('Invalid mapping: ' + JSON.stringify({
 369                 generated: aGenerated,
 370                 source: aSource,
 371                 original: aOriginal,
 372                 name: aName
 373               }));
 374             }
 375           };
 376
 377         /**
 378          * Serialize the accumulated mappings in to the stream of base 64 VLQs
 379          * specified by the source map format.
 380          */
 381         SourceMapGenerator.prototype._serializeMappings =
 382           function SourceMapGenerator_serializeMappings() {
 383             var previousGeneratedColumn = 0;
 384             var previousGeneratedLine = 1;
 385             var previousOriginalColumn = 0;
 386             var previousOriginalLine = 0;
 387             var previousName = 0;
 388             var previousSource = 0;
 389             var result = '';
 390             var next;
 391             var mapping;
 392             var nameIdx;
 393             var sourceIdx;
 394
 395             var mappings = this._mappings.toArray();
 396             for (var i = 0, len = mappings.length; i < len; i++) {
 397               mapping = mappings[i];
 398               next = ''
 399
 400               if (mapping.generatedLine !== previousGeneratedLine) {
 401                 previousGeneratedColumn = 0;
 402                 while (mapping.generatedLine !== previousGeneratedLine) {
 403                   next += ';';
 404                   previousGeneratedLine++;
 405                 }
 406               }
 407               else {
 408                 if (i > 0) {
 409                   if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
 410                     continue;
 411                   }
 412                   next += ',';
 413                 }
 414               }
 415
 416               next += base64VLQ.encode(mapping.generatedColumn
 417                                          - previousGeneratedColumn);
 418               previousGeneratedColumn = mapping.generatedColumn;
 419
 420               if (mapping.source != null) {
 421                 sourceIdx = this._sources.indexOf(mapping.source);
 422                 next += base64VLQ.encode(sourceIdx - previousSource);
 423                 previousSource = sourceIdx;
 424
 425                 // lines are stored 0-based in SourceMap spec version 3
 426                 next += base64VLQ.encode(mapping.originalLine - 1
 427                                            - previousOriginalLine);
 428                 previousOriginalLine = mapping.originalLine - 1;
 429
 430                 next += base64VLQ.encode(mapping.originalColumn
 431                                            - previousOriginalColumn);
 432                 previousOriginalColumn = mapping.originalColumn;
 433
 434                 if (mapping.name != null) {
 435                   nameIdx = this._names.indexOf(mapping.name);
 436                   next += base64VLQ.encode(nameIdx - previousName);
 437                   previousName = nameIdx;
 438                 }
 439               }
 440
 441               result += next;
 442             }
 443
 444             return result;
 445           };
 446
 447         SourceMapGenerator.prototype._generateSourcesContent =
 448           function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
 449             return aSources.map(function (source) {
 450               if (!this._sourcesContents) {
 451                 return null;
 452               }
 453               if (aSourceRoot != null) {
 454                 source = util.relative(aSourceRoot, source);
 455               }
 456               var key = util.toSetString(source);
 457               return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
 458                 ? this._sourcesContents[key]
 459                 : null;
 460             }, this);
 461           };
 462
 463         /**
 464          * Externalize the source map.
 465          */
 466         SourceMapGenerator.prototype.toJSON =
 467           function SourceMapGenerator_toJSON() {
 468             var map = {
 469               version: this._version,
 470               sources: this._sources.toArray(),
 471               names: this._names.toArray(),
 472               mappings: this._serializeMappings()
 473             };
 474             if (this._file != null) {
 475               map.file = this._file;
 476             }
 477             if (this._sourceRoot != null) {
 478               map.sourceRoot = this._sourceRoot;
 479             }
 480             if (this._sourcesContents) {
 481               map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
 482             }
 483
 484             return map;
 485           };
 486
 487         /**
 488          * Render the source map being generated to a string.
 489          */
 490         SourceMapGenerator.prototype.toString =
 491           function SourceMapGenerator_toString() {
 492             return JSON.stringify(this.toJSON());
 493           };
 494
 495         exports.SourceMapGenerator = SourceMapGenerator;
 496
 497
 498 /***/ }),
 499 /* 2 */
 500 /***/ (function(module, exports, __webpack_require__) {
 501
 502         /* -*- Mode: js; js-indent-level: 2; -*- */
 503         /*
 504          * Copyright 2011 Mozilla Foundation and contributors
 505          * Licensed under the New BSD license. See LICENSE or:
 506          * http://opensource.org/licenses/BSD-3-Clause
 507          *
 508          * Based on the Base 64 VLQ implementation in Closure Compiler:
 509          * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
 510          *
 511          * Copyright 2011 The Closure Compiler Authors. All rights reserved.
 512          * Redistribution and use in source and binary forms, with or without
 513          * modification, are permitted provided that the following conditions are
 514          * met:
 515          *
 516          *  * Redistributions of source code must retain the above copyright
 517          *    notice, this list of conditions and the following disclaimer.
 518          *  * Redistributions in binary form must reproduce the above
 519          *    copyright notice, this list of conditions and the following
 520          *    disclaimer in the documentation and/or other materials provided
 521          *    with the distribution.
 522          *  * Neither the name of Google Inc. nor the names of its
 523          *    contributors may be used to endorse or promote products derived
 524          *    from this software without specific prior written permission.
 525          *
 526          * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 527          * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 528          * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 529          * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 530          * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 531          * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 532          * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 533          * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 534          * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 535          * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 536          * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 537          */
 538
 539         var base64 = __webpack_require__(3);
 540
 541         // A single base 64 digit can contain 6 bits of data. For the base 64 variable
 542         // length quantities we use in the source map spec, the first bit is the sign,
 543         // the next four bits are the actual value, and the 6th bit is the
 544         // continuation bit. The continuation bit tells us whether there are more
 545         // digits in this value following this digit.
 546         //
 547         //   Continuation
 548         //   |    Sign
 549         //   |    |
 550         //   V    V
 551         //   101011
 552
 553         var VLQ_BASE_SHIFT = 5;
 554
 555         // binary: 100000
 556         var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
 557
 558         // binary: 011111
 559         var VLQ_BASE_MASK = VLQ_BASE - 1;
 560
 561         // binary: 100000
 562         var VLQ_CONTINUATION_BIT = VLQ_BASE;
 563
 564         /**
 565          * Converts from a two-complement value to a value where the sign bit is
 566          * placed in the least significant bit.  For example, as decimals:
 567          *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
 568          *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
 569          */
 570         function toVLQSigned(aValue) {
 571           return aValue < 0
 572             ? ((-aValue) << 1) + 1
 573             : (aValue << 1) + 0;
 574         }
 575
 576         /**
 577          * Converts to a two-complement value from a value where the sign bit is
 578          * placed in the least significant bit.  For example, as decimals:
 579          *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
 580          *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
 581          */
 582         function fromVLQSigned(aValue) {
 583           var isNegative = (aValue & 1) === 1;
 584           var shifted = aValue >> 1;
 585           return isNegative
 586             ? -shifted
 587             : shifted;
 588         }
 589
 590         /**
 591          * Returns the base 64 VLQ encoded value.
 592          */
 593         exports.encode = function base64VLQ_encode(aValue) {
 594           var encoded = "";
 595           var digit;
 596
 597           var vlq = toVLQSigned(aValue);
 598
 599           do {
 600             digit = vlq & VLQ_BASE_MASK;
 601             vlq >>>= VLQ_BASE_SHIFT;
 602             if (vlq > 0) {
 603               // There are still more digits in this value, so we must make sure the
 604               // continuation bit is marked.
 605               digit |= VLQ_CONTINUATION_BIT;
 606             }
 607             encoded += base64.encode(digit);
 608           } while (vlq > 0);
 609
 610           return encoded;
 611         };
 612
 613         /**
 614          * Decodes the next base 64 VLQ value from the given string and returns the
 615          * value and the rest of the string via the out parameter.
 616          */
 617         exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
 618           var strLen = aStr.length;
 619           var result = 0;
 620           var shift = 0;
 621           var continuation, digit;
 622
 623           do {
 624             if (aIndex >= strLen) {
 625               throw new Error("Expected more digits in base 64 VLQ value.");
 626             }
 627
 628             digit = base64.decode(aStr.charCodeAt(aIndex++));
 629             if (digit === -1) {
 630               throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
 631             }
 632
 633             continuation = !!(digit & VLQ_CONTINUATION_BIT);
 634             digit &= VLQ_BASE_MASK;
 635             result = result + (digit << shift);
 636             shift += VLQ_BASE_SHIFT;
 637           } while (continuation);
 638
 639           aOutParam.value = fromVLQSigned(result);
 640           aOutParam.rest = aIndex;
 641         };
 642
 643
 644 /***/ }),
 645 /* 3 */
 646 /***/ (function(module, exports) {
 647
 648         /* -*- Mode: js; js-indent-level: 2; -*- */
 649         /*
 650          * Copyright 2011 Mozilla Foundation and contributors
 651          * Licensed under the New BSD license. See LICENSE or:
 652          * http://opensource.org/licenses/BSD-3-Clause
 653          */
 654
 655         var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
 656
 657         /**
 658          * Encode an integer in the range of 0 to 63 to a single base 64 digit.
 659          */
 660         exports.encode = function (number) {
 661           if (0 <= number && number < intToCharMap.length) {
 662             return intToCharMap[number];
 663           }
 664           throw new TypeError("Must be between 0 and 63: " + number);
 665         };
 666
 667         /**
 668          * Decode a single base 64 character code digit to an integer. Returns -1 on
 669          * failure.
 670          */
 671         exports.decode = function (charCode) {
 672           var bigA = 65;     // 'A'
 673           var bigZ = 90;     // 'Z'
 674
 675           var littleA = 97;  // 'a'
 676           var littleZ = 122; // 'z'
 677
 678           var zero = 48;     // '0'
 679           var nine = 57;     // '9'
 680
 681           var plus = 43;     // '+'
 682           var slash = 47;    // '/'
 683
 684           var littleOffset = 26;
 685           var numberOffset = 52;
 686
 687           // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
 688           if (bigA <= charCode && charCode <= bigZ) {
 689             return (charCode - bigA);
 690           }
 691
 692           // 26 - 51: abcdefghijklmnopqrstuvwxyz
 693           if (littleA <= charCode && charCode <= littleZ) {
 694             return (charCode - littleA + littleOffset);
 695           }
 696
 697           // 52 - 61: 0123456789
 698           if (zero <= charCode && charCode <= nine) {
 699             return (charCode - zero + numberOffset);
 700           }
 701
 702           // 62: +
 703           if (charCode == plus) {
 704             return 62;
 705           }
 706
 707           // 63: /
 708           if (charCode == slash) {
 709             return 63;
 710           }
 711
 712           // Invalid base64 digit.
 713           return -1;
 714         };
 715
 716
 717 /***/ }),
 718 /* 4 */
 719 /***/ (function(module, exports) {
 720
 721         /* -*- Mode: js; js-indent-level: 2; -*- */
 722         /*
 723          * Copyright 2011 Mozilla Foundation and contributors
 724          * Licensed under the New BSD license. See LICENSE or:
 725          * http://opensource.org/licenses/BSD-3-Clause
 726          */
 727
 728         /**
 729          * This is a helper function for getting values from parameter/options
 730          * objects.
 731          *
 732          * @param args The object we are extracting values from
 733          * @param name The name of the property we are getting.
 734          * @param defaultValue An optional value to return if the property is missing
 735          * from the object. If this is not specified and the property is missing, an
 736          * error will be thrown.
 737          */
 738         function getArg(aArgs, aName, aDefaultValue) {
 739           if (aName in aArgs) {
 740             return aArgs[aName];
 741           } else if (arguments.length === 3) {
 742             return aDefaultValue;
 743           } else {
 744             throw new Error('"' + aName + '" is a required argument.');
 745           }
 746         }
 747         exports.getArg = getArg;
 748
 749         var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
 750         var dataUrlRegexp = /^data:.+\,.+$/;
 751
 752         function urlParse(aUrl) {
 753           var match = aUrl.match(urlRegexp);
 754           if (!match) {
 755             return null;
 756           }
 757           return {
 758             scheme: match[1],
 759             auth: match[2],
 760             host: match[3],
 761             port: match[4],
 762             path: match[5]
 763           };
 764         }
 765         exports.urlParse = urlParse;
 766
 767         function urlGenerate(aParsedUrl) {
 768           var url = '';
 769           if (aParsedUrl.scheme) {
 770             url += aParsedUrl.scheme + ':';
 771           }
 772           url += '//';
 773           if (aParsedUrl.auth) {
 774             url += aParsedUrl.auth + '@';
 775           }
 776           if (aParsedUrl.host) {
 777             url += aParsedUrl.host;
 778           }
 779           if (aParsedUrl.port) {
 780             url += ":" + aParsedUrl.port
 781           }
 782           if (aParsedUrl.path) {
 783             url += aParsedUrl.path;
 784           }
 785           return url;
 786         }
 787         exports.urlGenerate = urlGenerate;
 788
 789         /**
 790          * Normalizes a path, or the path portion of a URL:
 791          *
 792          * - Replaces consecutive slashes with one slash.
 793          * - Removes unnecessary '.' parts.
 794          * - Removes unnecessary '<dir>/..' parts.
 795          *
 796          * Based on code in the Node.js 'path' core module.
 797          *
 798          * @param aPath The path or url to normalize.
 799          */
 800         function normalize(aPath) {
 801           var path = aPath;
 802           var url = urlParse(aPath);
 803           if (url) {
 804             if (!url.path) {
 805               return aPath;
 806             }
 807             path = url.path;
 808           }
 809           var isAbsolute = exports.isAbsolute(path);
 810
 811           var parts = path.split(/\/+/);
 812           for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
 813             part = parts[i];
 814             if (part === '.') {
 815               parts.splice(i, 1);
 816             } else if (part === '..') {
 817               up++;
 818             } else if (up > 0) {
 819               if (part === '') {
 820                 // The first part is blank if the path is absolute. Trying to go
 821                 // above the root is a no-op. Therefore we can remove all '..' parts
 822                 // directly after the root.
 823                 parts.splice(i + 1, up);
 824                 up = 0;
 825               } else {
 826                 parts.splice(i, 2);
 827                 up--;
 828               }
 829             }
 830           }
 831           path = parts.join('/');
 832
 833           if (path === '') {
 834             path = isAbsolute ? '/' : '.';
 835           }
 836
 837           if (url) {
 838             url.path = path;
 839             return urlGenerate(url);
 840           }
 841           return path;
 842         }
 843         exports.normalize = normalize;
 844
 845         /**
 846          * Joins two paths/URLs.
 847          *
 848          * @param aRoot The root path or URL.
 849          * @param aPath The path or URL to be joined with the root.
 850          *
 851          * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
 852          *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
 853          *   first.
 854          * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
 855          *   is updated with the result and aRoot is returned. Otherwise the result
 856          *   is returned.
 857          *   - If aPath is absolute, the result is aPath.
 858          *   - Otherwise the two paths are joined with a slash.
 859          * - Joining for example 'http://' and 'www.example.com' is also supported.
 860          */
 861         function join(aRoot, aPath) {
 862           if (aRoot === "") {
 863             aRoot = ".";
 864           }
 865           if (aPath === "") {
 866             aPath = ".";
 867           }
 868           var aPathUrl = urlParse(aPath);
 869           var aRootUrl = urlParse(aRoot);
 870           if (aRootUrl) {
 871             aRoot = aRootUrl.path || '/';
 872           }
 873
 874           // `join(foo, '//www.example.org')`
 875           if (aPathUrl && !aPathUrl.scheme) {
 876             if (aRootUrl) {
 877               aPathUrl.scheme = aRootUrl.scheme;
 878             }
 879             return urlGenerate(aPathUrl);
 880           }
 881
 882           if (aPathUrl || aPath.match(dataUrlRegexp)) {
 883             return aPath;
 884           }
 885
 886           // `join('http://', 'www.example.com')`
 887           if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
 888             aRootUrl.host = aPath;
 889             return urlGenerate(aRootUrl);
 890           }
 891
 892           var joined = aPath.charAt(0) === '/'
 893             ? aPath
 894             : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
 895
 896           if (aRootUrl) {
 897             aRootUrl.path = joined;
 898             return urlGenerate(aRootUrl);
 899           }
 900           return joined;
 901         }
 902         exports.join = join;
 903
 904         exports.isAbsolute = function (aPath) {
 905           return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
 906         };
 907
 908         /**
 909          * Make a path relative to a URL or another path.
 910          *
 911          * @param aRoot The root path or URL.
 912          * @param aPath The path or URL to be made relative to aRoot.
 913          */
 914         function relative(aRoot, aPath) {
 915           if (aRoot === "") {
 916             aRoot = ".";
 917           }
 918
 919           aRoot = aRoot.replace(/\/$/, '');
 920
 921           // It is possible for the path to be above the root. In this case, simply
 922           // checking whether the root is a prefix of the path won't work. Instead, we
 923           // need to remove components from the root one by one, until either we find
 924           // a prefix that fits, or we run out of components to remove.
 925           var level = 0;
 926           while (aPath.indexOf(aRoot + '/') !== 0) {
 927             var index = aRoot.lastIndexOf("/");
 928             if (index < 0) {
 929               return aPath;
 930             }
 931
 932             // If the only part of the root that is left is the scheme (i.e. http://,
 933             // file:///, etc.), one or more slashes (/), or simply nothing at all, we
 934             // have exhausted all components, so the path is not relative to the root.
 935             aRoot = aRoot.slice(0, index);
 936             if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
 937               return aPath;
 938             }
 939
 940             ++level;
 941           }
 942
 943           // Make sure we add a "../" for each component we removed from the root.
 944           return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
 945         }
 946         exports.relative = relative;
 947
 948         var supportsNullProto = (function () {
 949           var obj = Object.create(null);
 950           return !('__proto__' in obj);
 951         }());
 952
 953         function identity (s) {
 954           return s;
 955         }
 956
 957         /**
 958          * Because behavior goes wacky when you set `__proto__` on objects, we
 959          * have to prefix all the strings in our set with an arbitrary character.
 960          *
 961          * See https://github.com/mozilla/source-map/pull/31 and
 962          * https://github.com/mozilla/source-map/issues/30
 963          *
 964          * @param String aStr
 965          */
 966         function toSetString(aStr) {
 967           if (isProtoString(aStr)) {
 968             return '$' + aStr;
 969           }
 970
 971           return aStr;
 972         }
 973         exports.toSetString = supportsNullProto ? identity : toSetString;
 974
 975         function fromSetString(aStr) {
 976           if (isProtoString(aStr)) {
 977             return aStr.slice(1);
 978           }
 979
 980           return aStr;
 981         }
 982         exports.fromSetString = supportsNullProto ? identity : fromSetString;
 983
 984         function isProtoString(s) {
 985           if (!s) {
 986             return false;
 987           }
 988
 989           var length = s.length;
 990
 991           if (length < 9 /* "__proto__".length */) {
 992             return false;
 993           }
 994
 995           if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
 996               s.charCodeAt(length - 2) !== 95  /* '_' */ ||
 997               s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
 998               s.charCodeAt(length - 4) !== 116 /* 't' */ ||
 999               s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
1000               s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
1001               s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
1002               s.charCodeAt(length - 8) !== 95  /* '_' */ ||
1003               s.charCodeAt(length - 9) !== 95  /* '_' */) {
1004             return false;
1005           }
1006
1007           for (var i = length - 10; i >= 0; i--) {
1008             if (s.charCodeAt(i) !== 36 /* '$' */) {
1009               return false;
1010             }
1011           }
1012
1013           return true;
1014         }
1015
1016         /**
1017          * Comparator between two mappings where the original positions are compared.
1018          *
1019          * Optionally pass in `true` as `onlyCompareGenerated` to consider two
1020          * mappings with the same original source/line/column, but different generated
1021          * line and column the same. Useful when searching for a mapping with a
1022          * stubbed out mapping.
1023          */
1024         function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
1025           var cmp = strcmp(mappingA.source, mappingB.source);
1026           if (cmp !== 0) {
1027             return cmp;
1028           }
1029
1030           cmp = mappingA.originalLine - mappingB.originalLine;
1031           if (cmp !== 0) {
1032             return cmp;
1033           }
1034
1035           cmp = mappingA.originalColumn - mappingB.originalColumn;
1036           if (cmp !== 0 || onlyCompareOriginal) {
1037             return cmp;
1038           }
1039
1040           cmp = mappingA.generatedColumn - mappingB.generatedColumn;
1041           if (cmp !== 0) {
1042             return cmp;
1043           }
1044
1045           cmp = mappingA.generatedLine - mappingB.generatedLine;
1046           if (cmp !== 0) {
1047             return cmp;
1048           }
1049
1050           return strcmp(mappingA.name, mappingB.name);
1051         }
1052         exports.compareByOriginalPositions = compareByOriginalPositions;
1053
1054         /**
1055          * Comparator between two mappings with deflated source and name indices where
1056          * the generated positions are compared.
1057          *
1058          * Optionally pass in `true` as `onlyCompareGenerated` to consider two
1059          * mappings with the same generated line and column, but different
1060          * source/name/original line and column the same. Useful when searching for a
1061          * mapping with a stubbed out mapping.
1062          */
1063         function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
1064           var cmp = mappingA.generatedLine - mappingB.generatedLine;
1065           if (cmp !== 0) {
1066             return cmp;
1067           }
1068
1069           cmp = mappingA.generatedColumn - mappingB.generatedColumn;
1070           if (cmp !== 0 || onlyCompareGenerated) {
1071             return cmp;
1072           }
1073
1074           cmp = strcmp(mappingA.source, mappingB.source);
1075           if (cmp !== 0) {
1076             return cmp;
1077           }
1078
1079           cmp = mappingA.originalLine - mappingB.originalLine;
1080           if (cmp !== 0) {
1081             return cmp;
1082           }
1083
1084           cmp = mappingA.originalColumn - mappingB.originalColumn;
1085           if (cmp !== 0) {
1086             return cmp;
1087           }
1088
1089           return strcmp(mappingA.name, mappingB.name);
1090         }
1091         exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
1092
1093         function strcmp(aStr1, aStr2) {
1094           if (aStr1 === aStr2) {
1095             return 0;
1096           }
1097
1098           if (aStr1 === null) {
1099             return 1; // aStr2 !== null
1100           }
1101
1102           if (aStr2 === null) {
1103             return -1; // aStr1 !== null
1104           }
1105
1106           if (aStr1 > aStr2) {
1107             return 1;
1108           }
1109
1110           return -1;
1111         }
1112
1113         /**
1114          * Comparator between two mappings with inflated source and name strings where
1115          * the generated positions are compared.
1116          */
1117         function compareByGeneratedPositionsInflated(mappingA, mappingB) {
1118           var cmp = mappingA.generatedLine - mappingB.generatedLine;
1119           if (cmp !== 0) {
1120             return cmp;
1121           }
1122
1123           cmp = mappingA.generatedColumn - mappingB.generatedColumn;
1124           if (cmp !== 0) {
1125             return cmp;
1126           }
1127
1128           cmp = strcmp(mappingA.source, mappingB.source);
1129           if (cmp !== 0) {
1130             return cmp;
1131           }
1132
1133           cmp = mappingA.originalLine - mappingB.originalLine;
1134           if (cmp !== 0) {
1135             return cmp;
1136           }
1137
1138           cmp = mappingA.originalColumn - mappingB.originalColumn;
1139           if (cmp !== 0) {
1140             return cmp;
1141           }
1142
1143           return strcmp(mappingA.name, mappingB.name);
1144         }
1145         exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
1146
1147         /**
1148          * Strip any JSON XSSI avoidance prefix from the string (as documented
1149          * in the source maps specification), and then parse the string as
1150          * JSON.
1151          */
1152         function parseSourceMapInput(str) {
1153           return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
1154         }
1155         exports.parseSourceMapInput = parseSourceMapInput;
1156
1157         /**
1158          * Compute the URL of a source given the the source root, the source's
1159          * URL, and the source map's URL.
1160          */
1161         function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
1162           sourceURL = sourceURL || '';
1163
1164           if (sourceRoot) {
1165             // This follows what Chrome does.
1166             if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
1167               sourceRoot += '/';
1168             }
1169             // The spec says:
1170             //   Line 4: An optional source root, useful for relocating source
1171             //   files on a server or removing repeated values in the
1172             //   “sources” entry.  This value is prepended to the individual
1173             //   entries in the “source” field.
1174             sourceURL = sourceRoot + sourceURL;
1175           }
1176
1177           // Historically, SourceMapConsumer did not take the sourceMapURL as
1178           // a parameter.  This mode is still somewhat supported, which is why
1179           // this code block is conditional.  However, it's preferable to pass
1180           // the source map URL to SourceMapConsumer, so that this function
1181           // can implement the source URL resolution algorithm as outlined in
1182           // the spec.  This block is basically the equivalent of:
1183           //    new URL(sourceURL, sourceMapURL).toString()
1184           // ... except it avoids using URL, which wasn't available in the
1185           // older releases of node still supported by this library.
1186           //
1187           // The spec says:
1188           //   If the sources are not absolute URLs after prepending of the
1189           //   “sourceRoot”, the sources are resolved relative to the
1190           //   SourceMap (like resolving script src in a html document).
1191           if (sourceMapURL) {
1192             var parsed = urlParse(sourceMapURL);
1193             if (!parsed) {
1194               throw new Error("sourceMapURL could not be parsed");
1195             }
1196             if (parsed.path) {
1197               // Strip the last path component, but keep the "/".
1198               var index = parsed.path.lastIndexOf('/');
1199               if (index >= 0) {
1200                 parsed.path = parsed.path.substring(0, index + 1);
1201               }
1202             }
1203             sourceURL = join(urlGenerate(parsed), sourceURL);
1204           }
1205
1206           return normalize(sourceURL);
1207         }
1208         exports.computeSourceURL = computeSourceURL;
1209
1210
1211 /***/ }),
1212 /* 5 */
1213 /***/ (function(module, exports, __webpack_require__) {
1214
1215         /* -*- Mode: js; js-indent-level: 2; -*- */
1216         /*
1217          * Copyright 2011 Mozilla Foundation and contributors
1218          * Licensed under the New BSD license. See LICENSE or:
1219          * http://opensource.org/licenses/BSD-3-Clause
1220          */
1221
1222         var util = __webpack_require__(4);
1223         var has = Object.prototype.hasOwnProperty;
1224         var hasNativeMap = typeof Map !== "undefined";
1225
1226         /**
1227          * A data structure which is a combination of an array and a set. Adding a new
1228          * member is O(1), testing for membership is O(1), and finding the index of an
1229          * element is O(1). Removing elements from the set is not supported. Only
1230          * strings are supported for membership.
1231          */
1232         function ArraySet() {
1233           this._array = [];
1234           this._set = hasNativeMap ? new Map() : Object.create(null);
1235         }
1236
1237         /**
1238          * Static method for creating ArraySet instances from an existing array.
1239          */
1240         ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
1241           var set = new ArraySet();
1242           for (var i = 0, len = aArray.length; i < len; i++) {
1243             set.add(aArray[i], aAllowDuplicates);
1244           }
1245           return set;
1246         };
1247
1248         /**
1249          * Return how many unique items are in this ArraySet. If duplicates have been
1250          * added, than those do not count towards the size.
1251          *
1252          * @returns Number
1253          */
1254         ArraySet.prototype.size = function ArraySet_size() {
1255           return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
1256         };
1257
1258         /**
1259          * Add the given string to this set.
1260          *
1261          * @param String aStr
1262          */
1263         ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
1264           var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
1265           var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
1266           var idx = this._array.length;
1267           if (!isDuplicate || aAllowDuplicates) {
1268             this._array.push(aStr);
1269           }
1270           if (!isDuplicate) {
1271             if (hasNativeMap) {
1272               this._set.set(aStr, idx);
1273             } else {
1274               this._set[sStr] = idx;
1275             }
1276           }
1277         };
1278
1279         /**
1280          * Is the given string a member of this set?
1281          *
1282          * @param String aStr
1283          */
1284         ArraySet.prototype.has = function ArraySet_has(aStr) {
1285           if (hasNativeMap) {
1286             return this._set.has(aStr);
1287           } else {
1288             var sStr = util.toSetString(aStr);
1289             return has.call(this._set, sStr);
1290           }
1291         };
1292
1293         /**
1294          * What is the index of the given string in the array?
1295          *
1296          * @param String aStr
1297          */
1298         ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
1299           if (hasNativeMap) {
1300             var idx = this._set.get(aStr);
1301             if (idx >= 0) {
1302                 return idx;
1303             }
1304           } else {
1305             var sStr = util.toSetString(aStr);
1306             if (has.call(this._set, sStr)) {
1307               return this._set[sStr];
1308             }
1309           }
1310
1311           throw new Error('"' + aStr + '" is not in the set.');
1312         };
1313
1314         /**
1315          * What is the element at the given index?
1316          *
1317          * @param Number aIdx
1318          */
1319         ArraySet.prototype.at = function ArraySet_at(aIdx) {
1320           if (aIdx >= 0 && aIdx < this._array.length) {
1321             return this._array[aIdx];
1322           }
1323           throw new Error('No element indexed by ' + aIdx);
1324         };
1325
1326         /**
1327          * Returns the array representation of this set (which has the proper indices
1328          * indicated by indexOf). Note that this is a copy of the internal array used
1329          * for storing the members so that no one can mess with internal state.
1330          */
1331         ArraySet.prototype.toArray = function ArraySet_toArray() {
1332           return this._array.slice();
1333         };
1334
1335         exports.ArraySet = ArraySet;
1336
1337
1338 /***/ }),
1339 /* 6 */
1340 /***/ (function(module, exports, __webpack_require__) {
1341
1342         /* -*- Mode: js; js-indent-level: 2; -*- */
1343         /*
1344          * Copyright 2014 Mozilla Foundation and contributors
1345          * Licensed under the New BSD license. See LICENSE or:
1346          * http://opensource.org/licenses/BSD-3-Clause
1347          */
1348
1349         var util = __webpack_require__(4);
1350
1351         /**
1352          * Determine whether mappingB is after mappingA with respect to generated
1353          * position.
1354          */
1355         function generatedPositionAfter(mappingA, mappingB) {
1356           // Optimized for most common case
1357           var lineA = mappingA.generatedLine;
1358           var lineB = mappingB.generatedLine;
1359           var columnA = mappingA.generatedColumn;
1360           var columnB = mappingB.generatedColumn;
1361           return lineB > lineA || lineB == lineA && columnB >= columnA ||
1362                  util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
1363         }
1364
1365         /**
1366          * A data structure to provide a sorted view of accumulated mappings in a
1367          * performance conscious manner. It trades a neglibable overhead in general
1368          * case for a large speedup in case of mappings being added in order.
1369          */
1370         function MappingList() {
1371           this._array = [];
1372           this._sorted = true;
1373           // Serves as infimum
1374           this._last = {generatedLine: -1, generatedColumn: 0};
1375         }
1376
1377         /**
1378          * Iterate through internal items. This method takes the same arguments that
1379          * `Array.prototype.forEach` takes.
1380          *
1381          * NOTE: The order of the mappings is NOT guaranteed.
1382          */
1383         MappingList.prototype.unsortedForEach =
1384           function MappingList_forEach(aCallback, aThisArg) {
1385             this._array.forEach(aCallback, aThisArg);
1386           };
1387
1388         /**
1389          * Add the given source mapping.
1390          *
1391          * @param Object aMapping
1392          */
1393         MappingList.prototype.add = function MappingList_add(aMapping) {
1394           if (generatedPositionAfter(this._last, aMapping)) {
1395             this._last = aMapping;
1396             this._array.push(aMapping);
1397           } else {
1398             this._sorted = false;
1399             this._array.push(aMapping);
1400           }
1401         };
1402
1403         /**
1404          * Returns the flat, sorted array of mappings. The mappings are sorted by
1405          * generated position.
1406          *
1407          * WARNING: This method returns internal data without copying, for
1408          * performance. The return value must NOT be mutated, and should be treated as
1409          * an immutable borrow. If you want to take ownership, you must make your own
1410          * copy.
1411          */
1412         MappingList.prototype.toArray = function MappingList_toArray() {
1413           if (!this._sorted) {
1414             this._array.sort(util.compareByGeneratedPositionsInflated);
1415             this._sorted = true;
1416           }
1417           return this._array;
1418         };
1419
1420         exports.MappingList = MappingList;
1421
1422
1423 /***/ }),
1424 /* 7 */
1425 /***/ (function(module, exports, __webpack_require__) {
1426
1427         /* -*- Mode: js; js-indent-level: 2; -*- */
1428         /*
1429          * Copyright 2011 Mozilla Foundation and contributors
1430          * Licensed under the New BSD license. See LICENSE or:
1431          * http://opensource.org/licenses/BSD-3-Clause
1432          */
1433
1434         var util = __webpack_require__(4);
1435         var binarySearch = __webpack_require__(8);
1436         var ArraySet = __webpack_require__(5).ArraySet;
1437         var base64VLQ = __webpack_require__(2);
1438         var quickSort = __webpack_require__(9).quickSort;
1439
1440         function SourceMapConsumer(aSourceMap, aSourceMapURL) {
1441           var sourceMap = aSourceMap;
1442           if (typeof aSourceMap === 'string') {
1443             sourceMap = util.parseSourceMapInput(aSourceMap);
1444           }
1445
1446           return sourceMap.sections != null
1447             ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
1448             : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
1449         }
1450
1451         SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
1452           return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
1453         }
1454
1455         /**
1456          * The version of the source mapping spec that we are consuming.
1457          */
1458         SourceMapConsumer.prototype._version = 3;
1459
1460         // `__generatedMappings` and `__originalMappings` are arrays that hold the
1461         // parsed mapping coordinates from the source map's "mappings" attribute. They
1462         // are lazily instantiated, accessed via the `_generatedMappings` and
1463         // `_originalMappings` getters respectively, and we only parse the mappings
1464         // and create these arrays once queried for a source location. We jump through
1465         // these hoops because there can be many thousands of mappings, and parsing
1466         // them is expensive, so we only want to do it if we must.
1467         //
1468         // Each object in the arrays is of the form:
1469         //
1470         //     {
1471         //       generatedLine: The line number in the generated code,
1472         //       generatedColumn: The column number in the generated code,
1473         //       source: The path to the original source file that generated this
1474         //               chunk of code,
1475         //       originalLine: The line number in the original source that
1476         //                     corresponds to this chunk of generated code,
1477         //       originalColumn: The column number in the original source that
1478         //                       corresponds to this chunk of generated code,
1479         //       name: The name of the original symbol which generated this chunk of
1480         //             code.
1481         //     }
1482         //
1483         // All properties except for `generatedLine` and `generatedColumn` can be
1484         // `null`.
1485         //
1486         // `_generatedMappings` is ordered by the generated positions.
1487         //
1488         // `_originalMappings` is ordered by the original positions.
1489
1490         SourceMapConsumer.prototype.__generatedMappings = null;
1491         Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
1492           configurable: true,
1493           enumerable: true,
1494           get: function () {
1495             if (!this.__generatedMappings) {
1496               this._parseMappings(this._mappings, this.sourceRoot);
1497             }
1498
1499             return this.__generatedMappings;
1500           }
1501         });
1502
1503         SourceMapConsumer.prototype.__originalMappings = null;
1504         Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
1505           configurable: true,
1506           enumerable: true,
1507           get: function () {
1508             if (!this.__originalMappings) {
1509               this._parseMappings(this._mappings, this.sourceRoot);
1510             }
1511
1512             return this.__originalMappings;
1513           }
1514         });
1515
1516         SourceMapConsumer.prototype._charIsMappingSeparator =
1517           function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
1518             var c = aStr.charAt(index);
1519             return c === ";" || c === ",";
1520           };
1521
1522         /**
1523          * Parse the mappings in a string in to a data structure which we can easily
1524          * query (the ordered arrays in the `this.__generatedMappings` and
1525          * `this.__originalMappings` properties).
1526          */
1527         SourceMapConsumer.prototype._parseMappings =
1528           function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
1529             throw new Error("Subclasses must implement _parseMappings");
1530           };
1531
1532         SourceMapConsumer.GENERATED_ORDER = 1;
1533         SourceMapConsumer.ORIGINAL_ORDER = 2;
1534
1535         SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
1536         SourceMapConsumer.LEAST_UPPER_BOUND = 2;
1537
1538         /**
1539          * Iterate over each mapping between an original source/line/column and a
1540          * generated line/column in this source map.
1541          *
1542          * @param Function aCallback
1543          *        The function that is called with each mapping.
1544          * @param Object aContext
1545          *        Optional. If specified, this object will be the value of `this` every
1546          *        time that `aCallback` is called.
1547          * @param aOrder
1548          *        Either `SourceMapConsumer.GENERATED_ORDER` or
1549          *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
1550          *        iterate over the mappings sorted by the generated file's line/column
1551          *        order or the original's source/line/column order, respectively. Defaults to
1552          *        `SourceMapConsumer.GENERATED_ORDER`.
1553          */
1554         SourceMapConsumer.prototype.eachMapping =
1555           function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
1556             var context = aContext || null;
1557             var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
1558
1559             var mappings;
1560             switch (order) {
1561             case SourceMapConsumer.GENERATED_ORDER:
1562               mappings = this._generatedMappings;
1563               break;
1564             case SourceMapConsumer.ORIGINAL_ORDER:
1565               mappings = this._originalMappings;
1566               break;
1567             default:
1568               throw new Error("Unknown order of iteration.");
1569             }
1570
1571             var sourceRoot = this.sourceRoot;
1572             mappings.map(function (mapping) {
1573               var source = mapping.source === null ? null : this._sources.at(mapping.source);
1574               source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
1575               return {
1576                 source: source,
1577                 generatedLine: mapping.generatedLine,
1578                 generatedColumn: mapping.generatedColumn,
1579                 originalLine: mapping.originalLine,
1580                 originalColumn: mapping.originalColumn,
1581                 name: mapping.name === null ? null : this._names.at(mapping.name)
1582               };
1583             }, this).forEach(aCallback, context);
1584           };
1585
1586         /**
1587          * Returns all generated line and column information for the original source,
1588          * line, and column provided. If no column is provided, returns all mappings
1589          * corresponding to a either the line we are searching for or the next
1590          * closest line that has any mappings. Otherwise, returns all mappings
1591          * corresponding to the given line and either the column we are searching for
1592          * or the next closest column that has any offsets.
1593          *
1594          * The only argument is an object with the following properties:
1595          *
1596          *   - source: The filename of the original source.
1597          *   - line: The line number in the original source.  The line number is 1-based.
1598          *   - column: Optional. the column number in the original source.
1599          *    The column number is 0-based.
1600          *
1601          * and an array of objects is returned, each with the following properties:
1602          *
1603          *   - line: The line number in the generated source, or null.  The
1604          *    line number is 1-based.
1605          *   - column: The column number in the generated source, or null.
1606          *    The column number is 0-based.
1607          */
1608         SourceMapConsumer.prototype.allGeneratedPositionsFor =
1609           function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
1610             var line = util.getArg(aArgs, 'line');
1611
1612             // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
1613             // returns the index of the closest mapping less than the needle. By
1614             // setting needle.originalColumn to 0, we thus find the last mapping for
1615             // the given line, provided such a mapping exists.
1616             var needle = {
1617               source: util.getArg(aArgs, 'source'),
1618               originalLine: line,
1619               originalColumn: util.getArg(aArgs, 'column', 0)
1620             };
1621
1622             needle.source = this._findSourceIndex(needle.source);
1623             if (needle.source < 0) {
1624               return [];
1625             }
1626
1627             var mappings = [];
1628
1629             var index = this._findMapping(needle,
1630                                           this._originalMappings,
1631                                           "originalLine",
1632                                           "originalColumn",
1633                                           util.compareByOriginalPositions,
1634                                           binarySearch.LEAST_UPPER_BOUND);
1635             if (index >= 0) {
1636               var mapping = this._originalMappings[index];
1637
1638               if (aArgs.column === undefined) {
1639                 var originalLine = mapping.originalLine;
1640
1641                 // Iterate until either we run out of mappings, or we run into
1642                 // a mapping for a different line than the one we found. Since
1643                 // mappings are sorted, this is guaranteed to find all mappings for
1644                 // the line we found.
1645                 while (mapping && mapping.originalLine === originalLine) {
1646                   mappings.push({
1647                     line: util.getArg(mapping, 'generatedLine', null),
1648                     column: util.getArg(mapping, 'generatedColumn', null),
1649                     lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
1650                   });
1651
1652                   mapping = this._originalMappings[++index];
1653                 }
1654               } else {
1655                 var originalColumn = mapping.originalColumn;
1656
1657                 // Iterate until either we run out of mappings, or we run into
1658                 // a mapping for a different line than the one we were searching for.
1659                 // Since mappings are sorted, this is guaranteed to find all mappings for
1660                 // the line we are searching for.
1661                 while (mapping &&
1662                        mapping.originalLine === line &&
1663                        mapping.originalColumn == originalColumn) {
1664                   mappings.push({
1665                     line: util.getArg(mapping, 'generatedLine', null),
1666                     column: util.getArg(mapping, 'generatedColumn', null),
1667                     lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
1668                   });
1669
1670                   mapping = this._originalMappings[++index];
1671                 }
1672               }
1673             }
1674
1675             return mappings;
1676           };
1677
1678         exports.SourceMapConsumer = SourceMapConsumer;
1679
1680         /**
1681          * A BasicSourceMapConsumer instance represents a parsed source map which we can
1682          * query for information about the original file positions by giving it a file
1683          * position in the generated source.
1684          *
1685          * The first parameter is the raw source map (either as a JSON string, or
1686          * already parsed to an object). According to the spec, source maps have the
1687          * following attributes:
1688          *
1689          *   - version: Which version of the source map spec this map is following.
1690          *   - sources: An array of URLs to the original source files.
1691          *   - names: An array of identifiers which can be referrenced by individual mappings.
1692          *   - sourceRoot: Optional. The URL root from which all sources are relative.
1693          *   - sourcesContent: Optional. An array of contents of the original source files.
1694          *   - mappings: A string of base64 VLQs which contain the actual mappings.
1695          *   - file: Optional. The generated file this source map is associated with.
1696          *
1697          * Here is an example source map, taken from the source map spec[0]:
1698          *
1699          *     {
1700          *       version : 3,
1701          *       file: "out.js",
1702          *       sourceRoot : "",
1703          *       sources: ["foo.js", "bar.js"],
1704          *       names: ["src", "maps", "are", "fun"],
1705          *       mappings: "AA,AB;;ABCDE;"
1706          *     }
1707          *
1708          * The second parameter, if given, is a string whose value is the URL
1709          * at which the source map was found.  This URL is used to compute the
1710          * sources array.
1711          *
1712          * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
1713          */
1714         function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
1715           var sourceMap = aSourceMap;
1716           if (typeof aSourceMap === 'string') {
1717             sourceMap = util.parseSourceMapInput(aSourceMap);
1718           }
1719
1720           var version = util.getArg(sourceMap, 'version');
1721           var sources = util.getArg(sourceMap, 'sources');
1722           // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
1723           // requires the array) to play nice here.
1724           var names = util.getArg(sourceMap, 'names', []);
1725           var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
1726           var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
1727           var mappings = util.getArg(sourceMap, 'mappings');
1728           var file = util.getArg(sourceMap, 'file', null);
1729
1730           // Once again, Sass deviates from the spec and supplies the version as a
1731           // string rather than a number, so we use loose equality checking here.
1732           if (version != this._version) {
1733             throw new Error('Unsupported version: ' + version);
1734           }
1735
1736           if (sourceRoot) {
1737             sourceRoot = util.normalize(sourceRoot);
1738           }
1739
1740           sources = sources
1741             .map(String)
1742             // Some source maps produce relative source paths like "./foo.js" instead of
1743             // "foo.js".  Normalize these first so that future comparisons will succeed.
1744             // See bugzil.la/1090768.
1745             .map(util.normalize)
1746             // Always ensure that absolute sources are internally stored relative to
1747             // the source root, if the source root is absolute. Not doing this would
1748             // be particularly problematic when the source root is a prefix of the
1749             // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
1750             .map(function (source) {
1751               return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
1752                 ? util.relative(sourceRoot, source)
1753                 : source;
1754             });
1755
1756           // Pass `true` below to allow duplicate names and sources. While source maps
1757           // are intended to be compressed and deduplicated, the TypeScript compiler
1758           // sometimes generates source maps with duplicates in them. See Github issue
1759           // #72 and bugzil.la/889492.
1760           this._names = ArraySet.fromArray(names.map(String), true);
1761           this._sources = ArraySet.fromArray(sources, true);
1762
1763           this._absoluteSources = this._sources.toArray().map(function (s) {
1764             return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
1765           });
1766
1767           this.sourceRoot = sourceRoot;
1768           this.sourcesContent = sourcesContent;
1769           this._mappings = mappings;
1770           this._sourceMapURL = aSourceMapURL;
1771           this.file = file;
1772         }
1773
1774         BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
1775         BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
1776
1777         /**
1778          * Utility function to find the index of a source.  Returns -1 if not
1779          * found.
1780          */
1781         BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
1782           var relativeSource = aSource;
1783           if (this.sourceRoot != null) {
1784             relativeSource = util.relative(this.sourceRoot, relativeSource);
1785           }
1786
1787           if (this._sources.has(relativeSource)) {
1788             return this._sources.indexOf(relativeSource);
1789           }
1790
1791           // Maybe aSource is an absolute URL as returned by |sources|.  In
1792           // this case we can't simply undo the transform.
1793           var i;
1794           for (i = 0; i < this._absoluteSources.length; ++i) {
1795             if (this._absoluteSources[i] == aSource) {
1796               return i;
1797             }
1798           }
1799
1800           return -1;
1801         };
1802
1803         /**
1804          * Create a BasicSourceMapConsumer from a SourceMapGenerator.
1805          *
1806          * @param SourceMapGenerator aSourceMap
1807          *        The source map that will be consumed.
1808          * @param String aSourceMapURL
1809          *        The URL at which the source map can be found (optional)
1810          * @returns BasicSourceMapConsumer
1811          */
1812         BasicSourceMapConsumer.fromSourceMap =
1813           function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
1814             var smc = Object.create(BasicSourceMapConsumer.prototype);
1815
1816             var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
1817             var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
1818             smc.sourceRoot = aSourceMap._sourceRoot;
1819             smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
1820                                                                     smc.sourceRoot);
1821             smc.file = aSourceMap._file;
1822             smc._sourceMapURL = aSourceMapURL;
1823             smc._absoluteSources = smc._sources.toArray().map(function (s) {
1824               return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
1825             });
1826
1827             // Because we are modifying the entries (by converting string sources and
1828             // names to indices into the sources and names ArraySets), we have to make
1829             // a copy of the entry or else bad things happen. Shared mutable state
1830             // strikes again! See github issue #191.
1831
1832             var generatedMappings = aSourceMap._mappings.toArray().slice();
1833             var destGeneratedMappings = smc.__generatedMappings = [];
1834             var destOriginalMappings = smc.__originalMappings = [];
1835
1836             for (var i = 0, length = generatedMappings.length; i < length; i++) {
1837               var srcMapping = generatedMappings[i];
1838               var destMapping = new Mapping;
1839               destMapping.generatedLine = srcMapping.generatedLine;
1840               destMapping.generatedColumn = srcMapping.generatedColumn;
1841
1842               if (srcMapping.source) {
1843                 destMapping.source = sources.indexOf(srcMapping.source);
1844                 destMapping.originalLine = srcMapping.originalLine;
1845                 destMapping.originalColumn = srcMapping.originalColumn;
1846
1847                 if (srcMapping.name) {
1848                   destMapping.name = names.indexOf(srcMapping.name);
1849                 }
1850
1851                 destOriginalMappings.push(destMapping);
1852               }
1853
1854               destGeneratedMappings.push(destMapping);
1855             }
1856
1857             quickSort(smc.__originalMappings, util.compareByOriginalPositions);
1858
1859             return smc;
1860           };
1861
1862         /**
1863          * The version of the source mapping spec that we are consuming.
1864          */
1865         BasicSourceMapConsumer.prototype._version = 3;
1866
1867         /**
1868          * The list of original sources.
1869          */
1870         Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
1871           get: function () {
1872             return this._absoluteSources.slice();
1873           }
1874         });
1875
1876         /**
1877          * Provide the JIT with a nice shape / hidden class.
1878          */
1879         function Mapping() {
1880           this.generatedLine = 0;
1881           this.generatedColumn = 0;
1882           this.source = null;
1883           this.originalLine = null;
1884           this.originalColumn = null;
1885           this.name = null;
1886         }
1887
1888         /**
1889          * Parse the mappings in a string in to a data structure which we can easily
1890          * query (the ordered arrays in the `this.__generatedMappings` and
1891          * `this.__originalMappings` properties).
1892          */
1893         BasicSourceMapConsumer.prototype._parseMappings =
1894           function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
1895             var generatedLine = 1;
1896             var previousGeneratedColumn = 0;
1897             var previousOriginalLine = 0;
1898             var previousOriginalColumn = 0;
1899             var previousSource = 0;
1900             var previousName = 0;
1901             var length = aStr.length;
1902             var index = 0;
1903             var cachedSegments = {};
1904             var temp = {};
1905             var originalMappings = [];
1906             var generatedMappings = [];
1907             var mapping, str, segment, end, value;
1908
1909             while (index < length) {
1910               if (aStr.charAt(index) === ';') {
1911                 generatedLine++;
1912                 index++;
1913                 previousGeneratedColumn = 0;
1914               }
1915               else if (aStr.charAt(index) === ',') {
1916                 index++;
1917               }
1918               else {
1919                 mapping = new Mapping();
1920                 mapping.generatedLine = generatedLine;
1921
1922                 // Because each offset is encoded relative to the previous one,
1923                 // many segments often have the same encoding. We can exploit this
1924                 // fact by caching the parsed variable length fields of each segment,
1925                 // allowing us to avoid a second parse if we encounter the same
1926                 // segment again.
1927                 for (end = index; end < length; end++) {
1928                   if (this._charIsMappingSeparator(aStr, end)) {
1929                     break;
1930                   }
1931                 }
1932                 str = aStr.slice(index, end);
1933
1934                 segment = cachedSegments[str];
1935                 if (segment) {
1936                   index += str.length;
1937                 } else {
1938                   segment = [];
1939                   while (index < end) {
1940                     base64VLQ.decode(aStr, index, temp);
1941                     value = temp.value;
1942                     index = temp.rest;
1943                     segment.push(value);
1944                   }
1945
1946                   if (segment.length === 2) {
1947                     throw new Error('Found a source, but no line and column');
1948                   }
1949
1950                   if (segment.length === 3) {
1951                     throw new Error('Found a source and line, but no column');
1952                   }
1953
1954                   cachedSegments[str] = segment;
1955                 }
1956
1957                 // Generated column.
1958                 mapping.generatedColumn = previousGeneratedColumn + segment[0];
1959                 previousGeneratedColumn = mapping.generatedColumn;
1960
1961                 if (segment.length > 1) {
1962                   // Original source.
1963                   mapping.source = previousSource + segment[1];
1964                   previousSource += segment[1];
1965
1966                   // Original line.
1967                   mapping.originalLine = previousOriginalLine + segment[2];
1968                   previousOriginalLine = mapping.originalLine;
1969                   // Lines are stored 0-based
1970                   mapping.originalLine += 1;
1971
1972                   // Original column.
1973                   mapping.originalColumn = previousOriginalColumn + segment[3];
1974                   previousOriginalColumn = mapping.originalColumn;
1975
1976                   if (segment.length > 4) {
1977                     // Original name.
1978                     mapping.name = previousName + segment[4];
1979                     previousName += segment[4];
1980                   }
1981                 }
1982
1983                 generatedMappings.push(mapping);
1984                 if (typeof mapping.originalLine === 'number') {
1985                   originalMappings.push(mapping);
1986                 }
1987               }
1988             }
1989
1990             quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
1991             this.__generatedMappings = generatedMappings;
1992
1993             quickSort(originalMappings, util.compareByOriginalPositions);
1994             this.__originalMappings = originalMappings;
1995           };
1996
1997         /**
1998          * Find the mapping that best matches the hypothetical "needle" mapping that
1999          * we are searching for in the given "haystack" of mappings.
2000          */
2001         BasicSourceMapConsumer.prototype._findMapping =
2002           function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
2003                                                  aColumnName, aComparator, aBias) {
2004             // To return the position we are searching for, we must first find the
2005             // mapping for the given position and then return the opposite position it
2006             // points to. Because the mappings are sorted, we can use binary search to
2007             // find the best mapping.
2008
2009             if (aNeedle[aLineName] <= 0) {
2010               throw new TypeError('Line must be greater than or equal to 1, got '
2011                                   + aNeedle[aLineName]);
2012             }
2013             if (aNeedle[aColumnName] < 0) {
2014               throw new TypeError('Column must be greater than or equal to 0, got '
2015                                   + aNeedle[aColumnName]);
2016             }
2017
2018             return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
2019           };
2020
2021         /**
2022          * Compute the last column for each generated mapping. The last column is
2023          * inclusive.
2024          */
2025         BasicSourceMapConsumer.prototype.computeColumnSpans =
2026           function SourceMapConsumer_computeColumnSpans() {
2027             for (var index = 0; index < this._generatedMappings.length; ++index) {
2028               var mapping = this._generatedMappings[index];
2029
2030               // Mappings do not contain a field for the last generated columnt. We
2031               // can come up with an optimistic estimate, however, by assuming that
2032               // mappings are contiguous (i.e. given two consecutive mappings, the
2033               // first mapping ends where the second one starts).
2034               if (index + 1 < this._generatedMappings.length) {
2035                 var nextMapping = this._generatedMappings[index + 1];
2036
2037                 if (mapping.generatedLine === nextMapping.generatedLine) {
2038                   mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
2039                   continue;
2040                 }
2041               }
2042
2043               // The last mapping for each line spans the entire line.
2044               mapping.lastGeneratedColumn = Infinity;
2045             }
2046           };
2047
2048         /**
2049          * Returns the original source, line, and column information for the generated
2050          * source's line and column positions provided. The only argument is an object
2051          * with the following properties:
2052          *
2053          *   - line: The line number in the generated source.  The line number
2054          *     is 1-based.
2055          *   - column: The column number in the generated source.  The column
2056          *     number is 0-based.
2057          *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
2058          *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
2059          *     closest element that is smaller than or greater than the one we are
2060          *     searching for, respectively, if the exact element cannot be found.
2061          *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
2062          *
2063          * and an object is returned with the following properties:
2064          *
2065          *   - source: The original source file, or null.
2066          *   - line: The line number in the original source, or null.  The
2067          *     line number is 1-based.
2068          *   - column: The column number in the original source, or null.  The
2069          *     column number is 0-based.
2070          *   - name: The original identifier, or null.
2071          */
2072         BasicSourceMapConsumer.prototype.originalPositionFor =
2073           function SourceMapConsumer_originalPositionFor(aArgs) {
2074             var needle = {
2075               generatedLine: util.getArg(aArgs, 'line'),
2076               generatedColumn: util.getArg(aArgs, 'column')
2077             };
2078
2079             var index = this._findMapping(
2080               needle,
2081               this._generatedMappings,
2082               "generatedLine",
2083               "generatedColumn",
2084               util.compareByGeneratedPositionsDeflated,
2085               util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
2086             );
2087
2088             if (index >= 0) {
2089               var mapping = this._generatedMappings[index];
2090
2091               if (mapping.generatedLine === needle.generatedLine) {
2092                 var source = util.getArg(mapping, 'source', null);
2093                 if (source !== null) {
2094                   source = this._sources.at(source);
2095                   source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
2096                 }
2097                 var name = util.getArg(mapping, 'name', null);
2098                 if (name !== null) {
2099                   name = this._names.at(name);
2100                 }
2101                 return {
2102                   source: source,
2103                   line: util.getArg(mapping, 'originalLine', null),
2104                   column: util.getArg(mapping, 'originalColumn', null),
2105                   name: name
2106                 };
2107               }
2108             }
2109
2110             return {
2111               source: null,
2112               line: null,
2113               column: null,
2114               name: null
2115             };
2116           };
2117
2118         /**
2119          * Return true if we have the source content for every source in the source
2120          * map, false otherwise.
2121          */
2122         BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
2123           function BasicSourceMapConsumer_hasContentsOfAllSources() {
2124             if (!this.sourcesContent) {
2125               return false;
2126             }
2127             return this.sourcesContent.length >= this._sources.size() &&
2128               !this.sourcesContent.some(function (sc) { return sc == null; });
2129           };
2130
2131         /**
2132          * Returns the original source content. The only argument is the url of the
2133          * original source file. Returns null if no original source content is
2134          * available.
2135          */
2136         BasicSourceMapConsumer.prototype.sourceContentFor =
2137           function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
2138             if (!this.sourcesContent) {
2139               return null;
2140             }
2141
2142             var index = this._findSourceIndex(aSource);
2143             if (index >= 0) {
2144               return this.sourcesContent[index];
2145             }
2146
2147             var relativeSource = aSource;
2148             if (this.sourceRoot != null) {
2149               relativeSource = util.relative(this.sourceRoot, relativeSource);
2150             }
2151
2152             var url;
2153             if (this.sourceRoot != null
2154                 && (url = util.urlParse(this.sourceRoot))) {
2155               // XXX: file:// URIs and absolute paths lead to unexpected behavior for
2156               // many users. We can help them out when they expect file:// URIs to
2157               // behave like it would if they were running a local HTTP server. See
2158               // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
2159               var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
2160               if (url.scheme == "file"
2161                   && this._sources.has(fileUriAbsPath)) {
2162                 return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
2163               }
2164
2165               if ((!url.path || url.path == "/")
2166                   && this._sources.has("/" + relativeSource)) {
2167                 return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
2168               }
2169             }
2170
2171             // This function is used recursively from
2172             // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
2173             // don't want to throw if we can't find the source - we just want to
2174             // return null, so we provide a flag to exit gracefully.
2175             if (nullOnMissing) {
2176               return null;
2177             }
2178             else {
2179               throw new Error('"' + relativeSource + '" is not in the SourceMap.');
2180             }
2181           };
2182
2183         /**
2184          * Returns the generated line and column information for the original source,
2185          * line, and column positions provided. The only argument is an object with
2186          * the following properties:
2187          *
2188          *   - source: The filename of the original source.
2189          *   - line: The line number in the original source.  The line number
2190          *     is 1-based.
2191          *   - column: The column number in the original source.  The column
2192          *     number is 0-based.
2193          *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
2194          *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
2195          *     closest element that is smaller than or greater than the one we are
2196          *     searching for, respectively, if the exact element cannot be found.
2197          *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
2198          *
2199          * and an object is returned with the following properties:
2200          *
2201          *   - line: The line number in the generated source, or null.  The
2202          *     line number is 1-based.
2203          *   - column: The column number in the generated source, or null.
2204          *     The column number is 0-based.
2205          */
2206         BasicSourceMapConsumer.prototype.generatedPositionFor =
2207           function SourceMapConsumer_generatedPositionFor(aArgs) {
2208             var source = util.getArg(aArgs, 'source');
2209             source = this._findSourceIndex(source);
2210             if (source < 0) {
2211               return {
2212                 line: null,
2213                 column: null,
2214                 lastColumn: null
2215               };
2216             }
2217
2218             var needle = {
2219               source: source,
2220               originalLine: util.getArg(aArgs, 'line'),
2221               originalColumn: util.getArg(aArgs, 'column')
2222             };
2223
2224             var index = this._findMapping(
2225               needle,
2226               this._originalMappings,
2227               "originalLine",
2228               "originalColumn",
2229               util.compareByOriginalPositions,
2230               util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
2231             );
2232
2233             if (index >= 0) {
2234               var mapping = this._originalMappings[index];
2235
2236               if (mapping.source === needle.source) {
2237                 return {
2238                   line: util.getArg(mapping, 'generatedLine', null),
2239                   column: util.getArg(mapping, 'generatedColumn', null),
2240                   lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
2241                 };
2242               }
2243             }
2244
2245             return {
2246               line: null,
2247               column: null,
2248               lastColumn: null
2249             };
2250           };
2251
2252         exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
2253
2254         /**
2255          * An IndexedSourceMapConsumer instance represents a parsed source map which
2256          * we can query for information. It differs from BasicSourceMapConsumer in
2257          * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
2258          * input.
2259          *
2260          * The first parameter is a raw source map (either as a JSON string, or already
2261          * parsed to an object). According to the spec for indexed source maps, they
2262          * have the following attributes:
2263          *
2264          *   - version: Which version of the source map spec this map is following.
2265          *   - file: Optional. The generated file this source map is associated with.
2266          *   - sections: A list of section definitions.
2267          *
2268          * Each value under the "sections" field has two fields:
2269          *   - offset: The offset into the original specified at which this section
2270          *       begins to apply, defined as an object with a "line" and "column"
2271          *       field.
2272          *   - map: A source map definition. This source map could also be indexed,
2273          *       but doesn't have to be.
2274          *
2275          * Instead of the "map" field, it's also possible to have a "url" field
2276          * specifying a URL to retrieve a source map from, but that's currently
2277          * unsupported.
2278          *
2279          * Here's an example source map, taken from the source map spec[0], but
2280          * modified to omit a section which uses the "url" field.
2281          *
2282          *  {
2283          *    version : 3,
2284          *    file: "app.js",
2285          *    sections: [{
2286          *      offset: {line:100, column:10},
2287          *      map: {
2288          *        version : 3,
2289          *        file: "section.js",
2290          *        sources: ["foo.js", "bar.js"],
2291          *        names: ["src", "maps", "are", "fun"],
2292          *        mappings: "AAAA,E;;ABCDE;"
2293          *      }
2294          *    }],
2295          *  }
2296          *
2297          * The second parameter, if given, is a string whose value is the URL
2298          * at which the source map was found.  This URL is used to compute the
2299          * sources array.
2300          *
2301          * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
2302          */
2303         function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
2304           var sourceMap = aSourceMap;
2305           if (typeof aSourceMap === 'string') {
2306             sourceMap = util.parseSourceMapInput(aSourceMap);
2307           }
2308
2309           var version = util.getArg(sourceMap, 'version');
2310           var sections = util.getArg(sourceMap, 'sections');
2311
2312           if (version != this._version) {
2313             throw new Error('Unsupported version: ' + version);
2314           }
2315
2316           this._sources = new ArraySet();
2317           this._names = new ArraySet();
2318
2319           var lastOffset = {
2320             line: -1,
2321             column: 0
2322           };
2323           this._sections = sections.map(function (s) {
2324             if (s.url) {
2325               // The url field will require support for asynchronicity.
2326               // See https://github.com/mozilla/source-map/issues/16
2327               throw new Error('Support for url field in sections not implemented.');
2328             }
2329             var offset = util.getArg(s, 'offset');
2330             var offsetLine = util.getArg(offset, 'line');
2331             var offsetColumn = util.getArg(offset, 'column');
2332
2333             if (offsetLine < lastOffset.line ||
2334                 (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
2335               throw new Error('Section offsets must be ordered and non-overlapping.');
2336             }
2337             lastOffset = offset;
2338
2339             return {
2340               generatedOffset: {
2341                 // The offset fields are 0-based, but we use 1-based indices when
2342                 // encoding/decoding from VLQ.
2343                 generatedLine: offsetLine + 1,
2344                 generatedColumn: offsetColumn + 1
2345               },
2346               consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
2347             }
2348           });
2349         }
2350
2351         IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
2352         IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
2353
2354         /**
2355          * The version of the source mapping spec that we are consuming.
2356          */
2357         IndexedSourceMapConsumer.prototype._version = 3;
2358
2359         /**
2360          * The list of original sources.
2361          */
2362         Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
2363           get: function () {
2364             var sources = [];
2365             for (var i = 0; i < this._sections.length; i++) {
2366               for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
2367                 sources.push(this._sections[i].consumer.sources[j]);
2368               }
2369             }
2370             return sources;
2371           }
2372         });
2373
2374         /**
2375          * Returns the original source, line, and column information for the generated
2376          * source's line and column positions provided. The only argument is an object
2377          * with the following properties:
2378          *
2379          *   - line: The line number in the generated source.  The line number
2380          *     is 1-based.
2381          *   - column: The column number in the generated source.  The column
2382          *     number is 0-based.
2383          *
2384          * and an object is returned with the following properties:
2385          *
2386          *   - source: The original source file, or null.
2387          *   - line: The line number in the original source, or null.  The
2388          *     line number is 1-based.
2389          *   - column: The column number in the original source, or null.  The
2390          *     column number is 0-based.
2391          *   - name: The original identifier, or null.
2392          */
2393         IndexedSourceMapConsumer.prototype.originalPositionFor =
2394           function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
2395             var needle = {
2396               generatedLine: util.getArg(aArgs, 'line'),
2397               generatedColumn: util.getArg(aArgs, 'column')
2398             };
2399
2400             // Find the section containing the generated position we're trying to map
2401             // to an original position.
2402             var sectionIndex = binarySearch.search(needle, this._sections,
2403               function(needle, section) {
2404                 var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
2405                 if (cmp) {
2406                   return cmp;
2407                 }
2408
2409                 return (needle.generatedColumn -
2410                         section.generatedOffset.generatedColumn);
2411               });
2412             var section = this._sections[sectionIndex];
2413
2414             if (!section) {
2415               return {
2416                 source: null,
2417                 line: null,
2418                 column: null,
2419                 name: null
2420               };
2421             }
2422
2423             return section.consumer.originalPositionFor({
2424               line: needle.generatedLine -
2425                 (section.generatedOffset.generatedLine - 1),
2426               column: needle.generatedColumn -
2427                 (section.generatedOffset.generatedLine === needle.generatedLine
2428                  ? section.generatedOffset.generatedColumn - 1
2429                  : 0),
2430               bias: aArgs.bias
2431             });
2432           };
2433
2434         /**
2435          * Return true if we have the source content for every source in the source
2436          * map, false otherwise.
2437          */
2438         IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
2439           function IndexedSourceMapConsumer_hasContentsOfAllSources() {
2440             return this._sections.every(function (s) {
2441               return s.consumer.hasContentsOfAllSources();
2442             });
2443           };
2444
2445         /**
2446          * Returns the original source content. The only argument is the url of the
2447          * original source file. Returns null if no original source content is
2448          * available.
2449          */
2450         IndexedSourceMapConsumer.prototype.sourceContentFor =
2451           function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
2452             for (var i = 0; i < this._sections.length; i++) {
2453               var section = this._sections[i];
2454
2455               var content = section.consumer.sourceContentFor(aSource, true);
2456               if (content) {
2457                 return content;
2458               }
2459             }
2460             if (nullOnMissing) {
2461               return null;
2462             }
2463             else {
2464               throw new Error('"' + aSource + '" is not in the SourceMap.');
2465             }
2466           };
2467
2468         /**
2469          * Returns the generated line and column information for the original source,
2470          * line, and column positions provided. The only argument is an object with
2471          * the following properties:
2472          *
2473          *   - source: The filename of the original source.
2474          *   - line: The line number in the original source.  The line number
2475          *     is 1-based.
2476          *   - column: The column number in the original source.  The column
2477          *     number is 0-based.
2478          *
2479          * and an object is returned with the following properties:
2480          *
2481          *   - line: The line number in the generated source, or null.  The
2482          *     line number is 1-based.
2483          *   - column: The column number in the generated source, or null.
2484          *     The column number is 0-based.
2485          */
2486         IndexedSourceMapConsumer.prototype.generatedPositionFor =
2487           function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
2488             for (var i = 0; i < this._sections.length; i++) {
2489               var section = this._sections[i];
2490
2491               // Only consider this section if the requested source is in the list of
2492               // sources of the consumer.
2493               if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
2494                 continue;
2495               }
2496               var generatedPosition = section.consumer.generatedPositionFor(aArgs);
2497               if (generatedPosition) {
2498                 var ret = {
2499                   line: generatedPosition.line +
2500                     (section.generatedOffset.generatedLine - 1),
2501                   column: generatedPosition.column +
2502                     (section.generatedOffset.generatedLine === generatedPosition.line
2503                      ? section.generatedOffset.generatedColumn - 1
2504                      : 0)
2505                 };
2506                 return ret;
2507               }
2508             }
2509
2510             return {
2511               line: null,
2512               column: null
2513             };
2514           };
2515
2516         /**
2517          * Parse the mappings in a string in to a data structure which we can easily
2518          * query (the ordered arrays in the `this.__generatedMappings` and
2519          * `this.__originalMappings` properties).
2520          */
2521         IndexedSourceMapConsumer.prototype._parseMappings =
2522           function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
2523             this.__generatedMappings = [];
2524             this.__originalMappings = [];
2525             for (var i = 0; i < this._sections.length; i++) {
2526               var section = this._sections[i];
2527               var sectionMappings = section.consumer._generatedMappings;
2528               for (var j = 0; j < sectionMappings.length; j++) {
2529                 var mapping = sectionMappings[j];
2530
2531                 var source = section.consumer._sources.at(mapping.source);
2532                 source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
2533                 this._sources.add(source);
2534                 source = this._sources.indexOf(source);
2535
2536                 var name = null;
2537                 if (mapping.name) {
2538                   name = section.consumer._names.at(mapping.name);
2539                   this._names.add(name);
2540                   name = this._names.indexOf(name);
2541                 }
2542
2543                 // The mappings coming from the consumer for the section have
2544                 // generated positions relative to the start of the section, so we
2545                 // need to offset them to be relative to the start of the concatenated
2546                 // generated file.
2547                 var adjustedMapping = {
2548                   source: source,
2549                   generatedLine: mapping.generatedLine +
2550                     (section.generatedOffset.generatedLine - 1),
2551                   generatedColumn: mapping.generatedColumn +
2552                     (section.generatedOffset.generatedLine === mapping.generatedLine
2553                     ? section.generatedOffset.generatedColumn - 1
2554                     : 0),
2555                   originalLine: mapping.originalLine,
2556                   originalColumn: mapping.originalColumn,
2557                   name: name
2558                 };
2559
2560                 this.__generatedMappings.push(adjustedMapping);
2561                 if (typeof adjustedMapping.originalLine === 'number') {
2562                   this.__originalMappings.push(adjustedMapping);
2563                 }
2564               }
2565             }
2566
2567             quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
2568             quickSort(this.__originalMappings, util.compareByOriginalPositions);
2569           };
2570
2571         exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
2572
2573
2574 /***/ }),
2575 /* 8 */
2576 /***/ (function(module, exports) {
2577
2578         /* -*- Mode: js; js-indent-level: 2; -*- */
2579         /*
2580          * Copyright 2011 Mozilla Foundation and contributors
2581          * Licensed under the New BSD license. See LICENSE or:
2582          * http://opensource.org/licenses/BSD-3-Clause
2583          */
2584
2585         exports.GREATEST_LOWER_BOUND = 1;
2586         exports.LEAST_UPPER_BOUND = 2;
2587
2588         /**
2589          * Recursive implementation of binary search.
2590          *
2591          * @param aLow Indices here and lower do not contain the needle.
2592          * @param aHigh Indices here and higher do not contain the needle.
2593          * @param aNeedle The element being searched for.
2594          * @param aHaystack The non-empty array being searched.
2595          * @param aCompare Function which takes two elements and returns -1, 0, or 1.
2596          * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
2597          *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
2598          *     closest element that is smaller than or greater than the one we are
2599          *     searching for, respectively, if the exact element cannot be found.
2600          */
2601         function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
2602           // This function terminates when one of the following is true:
2603           //
2604           //   1. We find the exact element we are looking for.
2605           //
2606           //   2. We did not find the exact element, but we can return the index of
2607           //      the next-closest element.
2608           //
2609           //   3. We did not find the exact element, and there is no next-closest
2610           //      element than the one we are searching for, so we return -1.
2611           var mid = Math.floor((aHigh - aLow) / 2) + aLow;
2612           var cmp = aCompare(aNeedle, aHaystack[mid], true);
2613           if (cmp === 0) {
2614             // Found the element we are looking for.
2615             return mid;
2616           }
2617           else if (cmp > 0) {
2618             // Our needle is greater than aHaystack[mid].
2619             if (aHigh - mid > 1) {
2620               // The element is in the upper half.
2621               return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
2622             }
2623
2624             // The exact needle element was not found in this haystack. Determine if
2625             // we are in termination case (3) or (2) and return the appropriate thing.
2626             if (aBias == exports.LEAST_UPPER_BOUND) {
2627               return aHigh < aHaystack.length ? aHigh : -1;
2628             } else {
2629               return mid;
2630             }
2631           }
2632           else {
2633             // Our needle is less than aHaystack[mid].
2634             if (mid - aLow > 1) {
2635               // The element is in the lower half.
2636               return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
2637             }
2638
2639             // we are in termination case (3) or (2) and return the appropriate thing.
2640             if (aBias == exports.LEAST_UPPER_BOUND) {
2641               return mid;
2642             } else {
2643               return aLow < 0 ? -1 : aLow;
2644             }
2645           }
2646         }
2647
2648         /**
2649          * This is an implementation of binary search which will always try and return
2650          * the index of the closest element if there is no exact hit. This is because
2651          * mappings between original and generated line/col pairs are single points,
2652          * and there is an implicit region between each of them, so a miss just means
2653          * that you aren't on the very start of a region.
2654          *
2655          * @param aNeedle The element you are looking for.
2656          * @param aHaystack The array that is being searched.
2657          * @param aCompare A function which takes the needle and an element in the
2658          *     array and returns -1, 0, or 1 depending on whether the needle is less
2659          *     than, equal to, or greater than the element, respectively.
2660          * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
2661          *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
2662          *     closest element that is smaller than or greater than the one we are
2663          *     searching for, respectively, if the exact element cannot be found.
2664          *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
2665          */
2666         exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
2667           if (aHaystack.length === 0) {
2668             return -1;
2669           }
2670
2671           var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
2672                                       aCompare, aBias || exports.GREATEST_LOWER_BOUND);
2673           if (index < 0) {
2674             return -1;
2675           }
2676
2677           // We have found either the exact element, or the next-closest element than
2678           // the one we are searching for. However, there may be more than one such
2679           // element. Make sure we always return the smallest of these.
2680           while (index - 1 >= 0) {
2681             if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
2682               break;
2683             }
2684             --index;
2685           }
2686
2687           return index;
2688         };
2689
2690
2691 /***/ }),
2692 /* 9 */
2693 /***/ (function(module, exports) {
2694
2695         /* -*- Mode: js; js-indent-level: 2; -*- */
2696         /*
2697          * Copyright 2011 Mozilla Foundation and contributors
2698          * Licensed under the New BSD license. See LICENSE or:
2699          * http://opensource.org/licenses/BSD-3-Clause
2700          */
2701
2702         // It turns out that some (most?) JavaScript engines don't self-host
2703         // `Array.prototype.sort`. This makes sense because C++ will likely remain
2704         // faster than JS when doing raw CPU-intensive sorting. However, when using a
2705         // custom comparator function, calling back and forth between the VM's C++ and
2706         // JIT'd JS is rather slow *and* loses JIT type information, resulting in
2707         // worse generated code for the comparator function than would be optimal. In
2708         // fact, when sorting with a comparator, these costs outweigh the benefits of
2709         // sorting in C++. By using our own JS-implemented Quick Sort (below), we get
2710         // a ~3500ms mean speed-up in `bench/bench.html`.
2711
2712         /**
2713          * Swap the elements indexed by `x` and `y` in the array `ary`.
2714          *
2715          * @param {Array} ary
2716          *        The array.
2717          * @param {Number} x
2718          *        The index of the first item.
2719          * @param {Number} y
2720          *        The index of the second item.
2721          */
2722         function swap(ary, x, y) {
2723           var temp = ary[x];
2724           ary[x] = ary[y];
2725           ary[y] = temp;
2726         }
2727
2728         /**
2729          * Returns a random integer within the range `low .. high` inclusive.
2730          *
2731          * @param {Number} low
2732          *        The lower bound on the range.
2733          * @param {Number} high
2734          *        The upper bound on the range.
2735          */
2736         function randomIntInRange(low, high) {
2737           return Math.round(low + (Math.random() * (high - low)));
2738         }
2739
2740         /**
2741          * The Quick Sort algorithm.
2742          *
2743          * @param {Array} ary
2744          *        An array to sort.
2745          * @param {function} comparator
2746          *        Function to use to compare two items.
2747          * @param {Number} p
2748          *        Start index of the array
2749          * @param {Number} r
2750          *        End index of the array
2751          */
2752         function doQuickSort(ary, comparator, p, r) {
2753           // If our lower bound is less than our upper bound, we (1) partition the
2754           // array into two pieces and (2) recurse on each half. If it is not, this is
2755           // the empty array and our base case.
2756
2757           if (p < r) {
2758             // (1) Partitioning.
2759             //
2760             // The partitioning chooses a pivot between `p` and `r` and moves all
2761             // elements that are less than or equal to the pivot to the before it, and
2762             // all the elements that are greater than it after it. The effect is that
2763             // once partition is done, the pivot is in the exact place it will be when
2764             // the array is put in sorted order, and it will not need to be moved
2765             // again. This runs in O(n) time.
2766
2767             // Always choose a random pivot so that an input array which is reverse
2768             // sorted does not cause O(n^2) running time.
2769             var pivotIndex = randomIntInRange(p, r);
2770             var i = p - 1;
2771
2772             swap(ary, pivotIndex, r);
2773             var pivot = ary[r];
2774
2775             // Immediately after `j` is incremented in this loop, the following hold
2776             // true:
2777             //
2778             //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
2779             //
2780             //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
2781             for (var j = p; j < r; j++) {
2782               if (comparator(ary[j], pivot) <= 0) {
2783                 i += 1;
2784                 swap(ary, i, j);
2785               }
2786             }
2787
2788             swap(ary, i + 1, j);
2789             var q = i + 1;
2790
2791             // (2) Recurse on each half.
2792
2793             doQuickSort(ary, comparator, p, q - 1);
2794             doQuickSort(ary, comparator, q + 1, r);
2795           }
2796         }
2797
2798         /**
2799          * Sort the given array in-place with the given comparator function.
2800          *
2801          * @param {Array} ary
2802          *        An array to sort.
2803          * @param {function} comparator
2804          *        Function to use to compare two items.
2805          */
2806         exports.quickSort = function (ary, comparator) {
2807           doQuickSort(ary, comparator, 0, ary.length - 1);
2808         };
2809
2810
2811 /***/ }),
2812 /* 10 */
2813 /***/ (function(module, exports, __webpack_require__) {
2814
2815         /* -*- Mode: js; js-indent-level: 2; -*- */
2816         /*
2817          * Copyright 2011 Mozilla Foundation and contributors
2818          * Licensed under the New BSD license. See LICENSE or:
2819          * http://opensource.org/licenses/BSD-3-Clause
2820          */
2821
2822         var SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;
2823         var util = __webpack_require__(4);
2824
2825         // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
2826         // operating systems these days (capturing the result).
2827         var REGEX_NEWLINE = /(\r?\n)/;
2828
2829         // Newline character code for charCodeAt() comparisons
2830         var NEWLINE_CODE = 10;
2831
2832         // Private symbol for identifying `SourceNode`s when multiple versions of
2833         // the source-map library are loaded. This MUST NOT CHANGE across
2834         // versions!
2835         var isSourceNode = "$$$isSourceNode$$$";
2836
2837         /**
2838          * SourceNodes provide a way to abstract over interpolating/concatenating
2839          * snippets of generated JavaScript source code while maintaining the line and
2840          * column information associated with the original source code.
2841          *
2842          * @param aLine The original line number.
2843          * @param aColumn The original column number.
2844          * @param aSource The original source's filename.
2845          * @param aChunks Optional. An array of strings which are snippets of
2846          *        generated JS, or other SourceNodes.
2847          * @param aName The original identifier.
2848          */
2849         function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
2850           this.children = [];
2851           this.sourceContents = {};
2852           this.line = aLine == null ? null : aLine;
2853           this.column = aColumn == null ? null : aColumn;
2854           this.source = aSource == null ? null : aSource;
2855           this.name = aName == null ? null : aName;
2856           this[isSourceNode] = true;
2857           if (aChunks != null) this.add(aChunks);
2858         }
2859
2860         /**
2861          * Creates a SourceNode from generated code and a SourceMapConsumer.
2862          *
2863          * @param aGeneratedCode The generated code
2864          * @param aSourceMapConsumer The SourceMap for the generated code
2865          * @param aRelativePath Optional. The path that relative sources in the
2866          *        SourceMapConsumer should be relative to.
2867          */
2868         SourceNode.fromStringWithSourceMap =
2869           function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
2870             // The SourceNode we want to fill with the generated code
2871             // and the SourceMap
2872             var node = new SourceNode();
2873
2874             // All even indices of this array are one line of the generated code,
2875             // while all odd indices are the newlines between two adjacent lines
2876             // (since `REGEX_NEWLINE` captures its match).
2877             // Processed fragments are accessed by calling `shiftNextLine`.
2878             var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
2879             var remainingLinesIndex = 0;
2880             var shiftNextLine = function() {
2881               var lineContents = getNextLine();
2882               // The last line of a file might not have a newline.
2883               var newLine = getNextLine() || "";
2884               return lineContents + newLine;
2885
2886               function getNextLine() {
2887                 return remainingLinesIndex < remainingLines.length ?
2888                     remainingLines[remainingLinesIndex++] : undefined;
2889               }
2890             };
2891
2892             // We need to remember the position of "remainingLines"
2893             var lastGeneratedLine = 1, lastGeneratedColumn = 0;
2894
2895             // The generate SourceNodes we need a code range.
2896             // To extract it current and last mapping is used.
2897             // Here we store the last mapping.
2898             var lastMapping = null;
2899
2900             aSourceMapConsumer.eachMapping(function (mapping) {
2901               if (lastMapping !== null) {
2902                 // We add the code from "lastMapping" to "mapping":
2903                 // First check if there is a new line in between.
2904                 if (lastGeneratedLine < mapping.generatedLine) {
2905                   // Associate first line with "lastMapping"
2906                   addMappingWithCode(lastMapping, shiftNextLine());
2907                   lastGeneratedLine++;
2908                   lastGeneratedColumn = 0;
2909                   // The remaining code is added without mapping
2910                 } else {
2911                   // There is no new line in between.
2912                   // Associate the code between "lastGeneratedColumn" and
2913                   // "mapping.generatedColumn" with "lastMapping"
2914                   var nextLine = remainingLines[remainingLinesIndex] || '';
2915                   var code = nextLine.substr(0, mapping.generatedColumn -
2916                                                 lastGeneratedColumn);
2917                   remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
2918                                                       lastGeneratedColumn);
2919                   lastGeneratedColumn = mapping.generatedColumn;
2920                   addMappingWithCode(lastMapping, code);
2921                   // No more remaining code, continue
2922                   lastMapping = mapping;
2923                   return;
2924                 }
2925               }
2926               // We add the generated code until the first mapping
2927               // to the SourceNode without any mapping.
2928               // Each line is added as separate string.
2929               while (lastGeneratedLine < mapping.generatedLine) {
2930                 node.add(shiftNextLine());
2931                 lastGeneratedLine++;
2932               }
2933               if (lastGeneratedColumn < mapping.generatedColumn) {
2934                 var nextLine = remainingLines[remainingLinesIndex] || '';
2935                 node.add(nextLine.substr(0, mapping.generatedColumn));
2936                 remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
2937                 lastGeneratedColumn = mapping.generatedColumn;
2938               }
2939               lastMapping = mapping;
2940             }, this);
2941             // We have processed all mappings.
2942             if (remainingLinesIndex < remainingLines.length) {
2943               if (lastMapping) {
2944                 // Associate the remaining code in the current line with "lastMapping"
2945                 addMappingWithCode(lastMapping, shiftNextLine());
2946               }
2947               // and add the remaining lines without any mapping
2948               node.add(remainingLines.splice(remainingLinesIndex).join(""));
2949             }
2950
2951             // Copy sourcesContent into SourceNode
2952             aSourceMapConsumer.sources.forEach(function (sourceFile) {
2953               var content = aSourceMapConsumer.sourceContentFor(sourceFile);
2954               if (content != null) {
2955                 if (aRelativePath != null) {
2956                   sourceFile = util.join(aRelativePath, sourceFile);
2957                 }
2958                 node.setSourceContent(sourceFile, content);
2959               }
2960             });
2961
2962             return node;
2963
2964             function addMappingWithCode(mapping, code) {
2965               if (mapping === null || mapping.source === undefined) {
2966                 node.add(code);
2967               } else {
2968                 var source = aRelativePath
2969                   ? util.join(aRelativePath, mapping.source)
2970                   : mapping.source;
2971                 node.add(new SourceNode(mapping.originalLine,
2972                                         mapping.originalColumn,
2973                                         source,
2974                                         code,
2975                                         mapping.name));
2976               }
2977             }
2978           };
2979
2980         /**
2981          * Add a chunk of generated JS to this source node.
2982          *
2983          * @param aChunk A string snippet of generated JS code, another instance of
2984          *        SourceNode, or an array where each member is one of those things.
2985          */
2986         SourceNode.prototype.add = function SourceNode_add(aChunk) {
2987           if (Array.isArray(aChunk)) {
2988             aChunk.forEach(function (chunk) {
2989               this.add(chunk);
2990             }, this);
2991           }
2992           else if (aChunk[isSourceNode] || typeof aChunk === "string") {
2993             if (aChunk) {
2994               this.children.push(aChunk);
2995             }
2996           }
2997           else {
2998             throw new TypeError(
2999               "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
3000             );
3001           }
3002           return this;
3003         };
3004
3005         /**
3006          * Add a chunk of generated JS to the beginning of this source node.
3007          *
3008          * @param aChunk A string snippet of generated JS code, another instance of
3009          *        SourceNode, or an array where each member is one of those things.
3010          */
3011         SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
3012           if (Array.isArray(aChunk)) {
3013             for (var i = aChunk.length-1; i >= 0; i--) {
3014               this.prepend(aChunk[i]);
3015             }
3016           }
3017           else if (aChunk[isSourceNode] || typeof aChunk === "string") {
3018             this.children.unshift(aChunk);
3019           }
3020           else {
3021             throw new TypeError(
3022               "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
3023             );
3024           }
3025           return this;
3026         };
3027
3028         /**
3029          * Walk over the tree of JS snippets in this node and its children. The
3030          * walking function is called once for each snippet of JS and is passed that
3031          * snippet and the its original associated source's line/column location.
3032          *
3033          * @param aFn The traversal function.
3034          */
3035         SourceNode.prototype.walk = function SourceNode_walk(aFn) {
3036           var chunk;
3037           for (var i = 0, len = this.children.length; i < len; i++) {
3038             chunk = this.children[i];
3039             if (chunk[isSourceNode]) {
3040               chunk.walk(aFn);
3041             }
3042             else {
3043               if (chunk !== '') {
3044                 aFn(chunk, { source: this.source,
3045                              line: this.line,
3046                              column: this.column,
3047                              name: this.name });
3048               }
3049             }
3050           }
3051         };
3052
3053         /**
3054          * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
3055          * each of `this.children`.
3056          *
3057          * @param aSep The separator.
3058          */
3059         SourceNode.prototype.join = function SourceNode_join(aSep) {
3060           var newChildren;
3061           var i;
3062           var len = this.children.length;
3063           if (len > 0) {
3064             newChildren = [];
3065             for (i = 0; i < len-1; i++) {
3066               newChildren.push(this.children[i]);
3067               newChildren.push(aSep);
3068             }
3069             newChildren.push(this.children[i]);
3070             this.children = newChildren;
3071           }
3072           return this;
3073         };
3074
3075         /**
3076          * Call String.prototype.replace on the very right-most source snippet. Useful
3077          * for trimming whitespace from the end of a source node, etc.
3078          *
3079          * @param aPattern The pattern to replace.
3080          * @param aReplacement The thing to replace the pattern with.
3081          */
3082         SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
3083           var lastChild = this.children[this.children.length - 1];
3084           if (lastChild[isSourceNode]) {
3085             lastChild.replaceRight(aPattern, aReplacement);
3086           }
3087           else if (typeof lastChild === 'string') {
3088             this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
3089           }
3090           else {
3091             this.children.push(''.replace(aPattern, aReplacement));
3092           }
3093           return this;
3094         };
3095
3096         /**
3097          * Set the source content for a source file. This will be added to the SourceMapGenerator
3098          * in the sourcesContent field.
3099          *
3100          * @param aSourceFile The filename of the source file
3101          * @param aSourceContent The content of the source file
3102          */
3103         SourceNode.prototype.setSourceContent =
3104           function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
3105             this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
3106           };
3107
3108         /**
3109          * Walk over the tree of SourceNodes. The walking function is called for each
3110          * source file content and is passed the filename and source content.
3111          *
3112          * @param aFn The traversal function.
3113          */
3114         SourceNode.prototype.walkSourceContents =
3115           function SourceNode_walkSourceContents(aFn) {
3116             for (var i = 0, len = this.children.length; i < len; i++) {
3117               if (this.children[i][isSourceNode]) {
3118                 this.children[i].walkSourceContents(aFn);
3119               }
3120             }
3121
3122             var sources = Object.keys(this.sourceContents);
3123             for (var i = 0, len = sources.length; i < len; i++) {
3124               aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
3125             }
3126           };
3127
3128         /**
3129          * Return the string representation of this source node. Walks over the tree
3130          * and concatenates all the various snippets together to one string.
3131          */
3132         SourceNode.prototype.toString = function SourceNode_toString() {
3133           var str = "";
3134           this.walk(function (chunk) {
3135             str += chunk;
3136           });
3137           return str;
3138         };
3139
3140         /**
3141          * Returns the string representation of this source node along with a source
3142          * map.
3143          */
3144         SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
3145           var generated = {
3146             code: "",
3147             line: 1,
3148             column: 0
3149           };
3150           var map = new SourceMapGenerator(aArgs);
3151           var sourceMappingActive = false;
3152           var lastOriginalSource = null;
3153           var lastOriginalLine = null;
3154           var lastOriginalColumn = null;
3155           var lastOriginalName = null;
3156           this.walk(function (chunk, original) {
3157             generated.code += chunk;
3158             if (original.source !== null
3159                 && original.line !== null
3160                 && original.column !== null) {
3161               if(lastOriginalSource !== original.source
3162                  || lastOriginalLine !== original.line
3163                  || lastOriginalColumn !== original.column
3164                  || lastOriginalName !== original.name) {
3165                 map.addMapping({
3166                   source: original.source,
3167                   original: {
3168                     line: original.line,
3169                     column: original.column
3170                   },
3171                   generated: {
3172                     line: generated.line,
3173                     column: generated.column
3174                   },
3175                   name: original.name
3176                 });
3177               }
3178               lastOriginalSource = original.source;
3179               lastOriginalLine = original.line;
3180               lastOriginalColumn = original.column;
3181               lastOriginalName = original.name;
3182               sourceMappingActive = true;
3183             } else if (sourceMappingActive) {
3184               map.addMapping({
3185                 generated: {
3186                   line: generated.line,
3187                   column: generated.column
3188                 }
3189               });
3190               lastOriginalSource = null;
3191               sourceMappingActive = false;
3192             }
3193             for (var idx = 0, length = chunk.length; idx < length; idx++) {
3194               if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
3195                 generated.line++;
3196                 generated.column = 0;
3197                 // Mappings end at eol
3198                 if (idx + 1 === length) {
3199                   lastOriginalSource = null;
3200                   sourceMappingActive = false;
3201                 } else if (sourceMappingActive) {
3202                   map.addMapping({
3203                     source: original.source,
3204                     original: {
3205                       line: original.line,
3206                       column: original.column
3207                     },
3208                     generated: {
3209                       line: generated.line,
3210                       column: generated.column
3211                     },
3212                     name: original.name
3213                   });
3214                 }
3215               } else {
3216                 generated.column++;
3217               }
3218             }
3219           });
3220           this.walkSourceContents(function (sourceFile, sourceContent) {
3221             map.setSourceContent(sourceFile, sourceContent);
3222           });
3223
3224           return { code: generated.code, map: map };
3225         };
3226
3227         exports.SourceNode = SourceNode;
3228
3229
3230 /***/ })
3231 /******/ ])
3232 });
3233 ;