ngannotate-rails 0.9.7 → 0.9.9

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,15 +1,15 @@
1
1
  ---
2
2
  !binary "U0hBMQ==":
3
3
  metadata.gz: !binary |-
4
- ZGFiNDQ4MDBiM2ZmYjQ0NjJiMmQ1MjViMjcwY2YyNTM1YTY2MmQ0Yg==
4
+ ODQ2NmUwNTEwZDE5MTA2YzUwZTg2ZGM0NWVlMjM2NzcxYzdhMWM3YQ==
5
5
  data.tar.gz: !binary |-
6
- MjNlMDMzZTUzMTVlYWEzY2FmODJhM2M1MDQzNzRhYjE0YzhiZTJkZQ==
6
+ MWNhYWZlMTQ3NzZmYmEzYmYzNzIzNmNjZmI0OThlMGVjYzg5YmJkMw==
7
7
  SHA512:
8
8
  metadata.gz: !binary |-
9
- MDcxNDAzMmIwMDU1ZWU4MGEwMWIwMzkyZmFlOTYyYzQ2NmY4NTQxMDkyOWY1
10
- NjVlYTY4ZWE2ZTU0YmY4N2I0YTI0Mzg2MDliNGY0YzQwNmY0OGUxMWFlYWU3
11
- YjVhMWI1NzQyYzFkMGIyZGM3ZmQ0MzJjNjE1ZGVmYzZlN2IxNzA=
9
+ YmE0MDM1MGYyNjI2NzEzMzlmNWZiYWE1NGMxNDRiZTk1MzYzMTA4ODYyNzRh
10
+ M2VmODNiMzhiOGFhNWVlNTY2MzAyNjY4MjM1OTZmOGFjN2VhMmI1NmFiYzk3
11
+ NGQxNzlhZDg1M2ZhMzhkODE4YTUxMmRmOGRhNWYxYTA5NzhkN2M=
12
12
  data.tar.gz: !binary |-
13
- Y2U4ZGYyYjFjNWFhZTNjMWVjMWUyZDM2OTU2NGNlZTYyNGY5ZjQwNDI1MzY2
14
- NmI1MThiOTdmYzk4MzAyNjY1MDY0MWEyMjIyODhlZTIzZTJkYWVmYjMzOTQy
15
- NTgyYzFhNDI5ZTJhNDMxZmFhYWQyZDFmYjRlYTUwYzBkMmRiODc=
13
+ MTkzNDQxZjc3OWFlMmE1MTdkYjcwYjU5OGE3OTAwNmQ5YWQ2ZmY3ZDMzNTZl
14
+ MGZiNzlkMzMyNTYwYWNiNjMzMzA4ZWVjZWM5Njc3YTU2NjcyZWJlNmViNWRh
15
+ MWI4Mzc1ODk4MzQwODExM2NiMjRmODM3ZjY1NjZlMTNkMThkNTM=
@@ -1,5 +1,5 @@
1
1
  module Ngannotate
2
2
  module Rails
3
- VERSION = "0.9.7"
3
+ VERSION = "0.9.9"
4
4
  end
5
5
  end
@@ -1,4 +1,4 @@
1
- (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
1
+ (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
2
2
  // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
3
3
  //
4
4
  // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
@@ -956,8 +956,8 @@ function hasOwnProperty(obj, prop) {
956
956
  return Object.prototype.hasOwnProperty.call(obj, prop);
957
957
  }
958
958
 
959
- }).call(this,require("FWaASH"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
960
- },{"./support/isBuffer":2,"FWaASH":5,"inherits":4}],4:[function(require,module,exports){
959
+ }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
960
+ },{"./support/isBuffer":2,"_process":7,"inherits":4}],4:[function(require,module,exports){
961
961
  if (typeof Object.create === 'function') {
962
962
  // implementation from standard node.js 'util' module
963
963
  module.exports = function inherits(ctor, superCtor) {
@@ -983,6 +983,281 @@ if (typeof Object.create === 'function') {
983
983
  }
984
984
 
985
985
  },{}],5:[function(require,module,exports){
986
+ exports.endianness = function () { return 'LE' };
987
+
988
+ exports.hostname = function () {
989
+ if (typeof location !== 'undefined') {
990
+ return location.hostname
991
+ }
992
+ else return '';
993
+ };
994
+
995
+ exports.loadavg = function () { return [] };
996
+
997
+ exports.uptime = function () { return 0 };
998
+
999
+ exports.freemem = function () {
1000
+ return Number.MAX_VALUE;
1001
+ };
1002
+
1003
+ exports.totalmem = function () {
1004
+ return Number.MAX_VALUE;
1005
+ };
1006
+
1007
+ exports.cpus = function () { return [] };
1008
+
1009
+ exports.type = function () { return 'Browser' };
1010
+
1011
+ exports.release = function () {
1012
+ if (typeof navigator !== 'undefined') {
1013
+ return navigator.appVersion;
1014
+ }
1015
+ return '';
1016
+ };
1017
+
1018
+ exports.networkInterfaces
1019
+ = exports.getNetworkInterfaces
1020
+ = function () { return {} };
1021
+
1022
+ exports.arch = function () { return 'javascript' };
1023
+
1024
+ exports.platform = function () { return 'browser' };
1025
+
1026
+ exports.tmpdir = exports.tmpDir = function () {
1027
+ return '/tmp';
1028
+ };
1029
+
1030
+ exports.EOL = '\n';
1031
+
1032
+ },{}],6:[function(require,module,exports){
1033
+ (function (process){
1034
+ // Copyright Joyent, Inc. and other Node contributors.
1035
+ //
1036
+ // Permission is hereby granted, free of charge, to any person obtaining a
1037
+ // copy of this software and associated documentation files (the
1038
+ // "Software"), to deal in the Software without restriction, including
1039
+ // without limitation the rights to use, copy, modify, merge, publish,
1040
+ // distribute, sublicense, and/or sell copies of the Software, and to permit
1041
+ // persons to whom the Software is furnished to do so, subject to the
1042
+ // following conditions:
1043
+ //
1044
+ // The above copyright notice and this permission notice shall be included
1045
+ // in all copies or substantial portions of the Software.
1046
+ //
1047
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1048
+ // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1049
+ // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
1050
+ // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
1051
+ // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
1052
+ // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
1053
+ // USE OR OTHER DEALINGS IN THE SOFTWARE.
1054
+
1055
+ // resolves . and .. elements in a path array with directory names there
1056
+ // must be no slashes, empty elements, or device names (c:\) in the array
1057
+ // (so also no leading and trailing slashes - it does not distinguish
1058
+ // relative and absolute paths)
1059
+ function normalizeArray(parts, allowAboveRoot) {
1060
+ // if the path tries to go above the root, `up` ends up > 0
1061
+ var up = 0;
1062
+ for (var i = parts.length - 1; i >= 0; i--) {
1063
+ var last = parts[i];
1064
+ if (last === '.') {
1065
+ parts.splice(i, 1);
1066
+ } else if (last === '..') {
1067
+ parts.splice(i, 1);
1068
+ up++;
1069
+ } else if (up) {
1070
+ parts.splice(i, 1);
1071
+ up--;
1072
+ }
1073
+ }
1074
+
1075
+ // if the path is allowed to go above the root, restore leading ..s
1076
+ if (allowAboveRoot) {
1077
+ for (; up--; up) {
1078
+ parts.unshift('..');
1079
+ }
1080
+ }
1081
+
1082
+ return parts;
1083
+ }
1084
+
1085
+ // Split a filename into [root, dir, basename, ext], unix version
1086
+ // 'root' is just a slash, or nothing.
1087
+ var splitPathRe =
1088
+ /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
1089
+ var splitPath = function(filename) {
1090
+ return splitPathRe.exec(filename).slice(1);
1091
+ };
1092
+
1093
+ // path.resolve([from ...], to)
1094
+ // posix version
1095
+ exports.resolve = function() {
1096
+ var resolvedPath = '',
1097
+ resolvedAbsolute = false;
1098
+
1099
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
1100
+ var path = (i >= 0) ? arguments[i] : process.cwd();
1101
+
1102
+ // Skip empty and invalid entries
1103
+ if (typeof path !== 'string') {
1104
+ throw new TypeError('Arguments to path.resolve must be strings');
1105
+ } else if (!path) {
1106
+ continue;
1107
+ }
1108
+
1109
+ resolvedPath = path + '/' + resolvedPath;
1110
+ resolvedAbsolute = path.charAt(0) === '/';
1111
+ }
1112
+
1113
+ // At this point the path should be resolved to a full absolute path, but
1114
+ // handle relative paths to be safe (might happen when process.cwd() fails)
1115
+
1116
+ // Normalize the path
1117
+ resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
1118
+ return !!p;
1119
+ }), !resolvedAbsolute).join('/');
1120
+
1121
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
1122
+ };
1123
+
1124
+ // path.normalize(path)
1125
+ // posix version
1126
+ exports.normalize = function(path) {
1127
+ var isAbsolute = exports.isAbsolute(path),
1128
+ trailingSlash = substr(path, -1) === '/';
1129
+
1130
+ // Normalize the path
1131
+ path = normalizeArray(filter(path.split('/'), function(p) {
1132
+ return !!p;
1133
+ }), !isAbsolute).join('/');
1134
+
1135
+ if (!path && !isAbsolute) {
1136
+ path = '.';
1137
+ }
1138
+ if (path && trailingSlash) {
1139
+ path += '/';
1140
+ }
1141
+
1142
+ return (isAbsolute ? '/' : '') + path;
1143
+ };
1144
+
1145
+ // posix version
1146
+ exports.isAbsolute = function(path) {
1147
+ return path.charAt(0) === '/';
1148
+ };
1149
+
1150
+ // posix version
1151
+ exports.join = function() {
1152
+ var paths = Array.prototype.slice.call(arguments, 0);
1153
+ return exports.normalize(filter(paths, function(p, index) {
1154
+ if (typeof p !== 'string') {
1155
+ throw new TypeError('Arguments to path.join must be strings');
1156
+ }
1157
+ return p;
1158
+ }).join('/'));
1159
+ };
1160
+
1161
+
1162
+ // path.relative(from, to)
1163
+ // posix version
1164
+ exports.relative = function(from, to) {
1165
+ from = exports.resolve(from).substr(1);
1166
+ to = exports.resolve(to).substr(1);
1167
+
1168
+ function trim(arr) {
1169
+ var start = 0;
1170
+ for (; start < arr.length; start++) {
1171
+ if (arr[start] !== '') break;
1172
+ }
1173
+
1174
+ var end = arr.length - 1;
1175
+ for (; end >= 0; end--) {
1176
+ if (arr[end] !== '') break;
1177
+ }
1178
+
1179
+ if (start > end) return [];
1180
+ return arr.slice(start, end - start + 1);
1181
+ }
1182
+
1183
+ var fromParts = trim(from.split('/'));
1184
+ var toParts = trim(to.split('/'));
1185
+
1186
+ var length = Math.min(fromParts.length, toParts.length);
1187
+ var samePartsLength = length;
1188
+ for (var i = 0; i < length; i++) {
1189
+ if (fromParts[i] !== toParts[i]) {
1190
+ samePartsLength = i;
1191
+ break;
1192
+ }
1193
+ }
1194
+
1195
+ var outputParts = [];
1196
+ for (var i = samePartsLength; i < fromParts.length; i++) {
1197
+ outputParts.push('..');
1198
+ }
1199
+
1200
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
1201
+
1202
+ return outputParts.join('/');
1203
+ };
1204
+
1205
+ exports.sep = '/';
1206
+ exports.delimiter = ':';
1207
+
1208
+ exports.dirname = function(path) {
1209
+ var result = splitPath(path),
1210
+ root = result[0],
1211
+ dir = result[1];
1212
+
1213
+ if (!root && !dir) {
1214
+ // No dirname whatsoever
1215
+ return '.';
1216
+ }
1217
+
1218
+ if (dir) {
1219
+ // It has a dirname, strip trailing slash
1220
+ dir = dir.substr(0, dir.length - 1);
1221
+ }
1222
+
1223
+ return root + dir;
1224
+ };
1225
+
1226
+
1227
+ exports.basename = function(path, ext) {
1228
+ var f = splitPath(path)[2];
1229
+ // TODO: make this comparison case-insensitive on windows?
1230
+ if (ext && f.substr(-1 * ext.length) === ext) {
1231
+ f = f.substr(0, f.length - ext.length);
1232
+ }
1233
+ return f;
1234
+ };
1235
+
1236
+
1237
+ exports.extname = function(path) {
1238
+ return splitPath(path)[3];
1239
+ };
1240
+
1241
+ function filter (xs, f) {
1242
+ if (xs.filter) return xs.filter(f);
1243
+ var res = [];
1244
+ for (var i = 0; i < xs.length; i++) {
1245
+ if (f(xs[i], i, xs)) res.push(xs[i]);
1246
+ }
1247
+ return res;
1248
+ }
1249
+
1250
+ // String.prototype.substr - negative index don't work in IE8
1251
+ var substr = 'ab'.substr(-1) === 'b'
1252
+ ? function (str, start, len) { return str.substr(start, len) }
1253
+ : function (str, start, len) {
1254
+ if (start < 0) start = str.length + start;
1255
+ return str.substr(start, len);
1256
+ }
1257
+ ;
1258
+
1259
+ }).call(this,require('_process'))
1260
+ },{"_process":7}],7:[function(require,module,exports){
986
1261
  // shim for using process in browser
987
1262
 
988
1263
  var process = module.exports = {};
@@ -1047,7 +1322,99 @@ process.chdir = function (dir) {
1047
1322
  throw new Error('process.chdir is not supported');
1048
1323
  };
1049
1324
 
1050
- },{}],6:[function(require,module,exports){
1325
+ },{}],8:[function(require,module,exports){
1326
+ "use strict";
1327
+
1328
+ var SourceMapGenerator = require("source-map").SourceMapGenerator;
1329
+ var stableSort = require("stable");
1330
+
1331
+ function SourceMapper(src, fragments, inFile, sourceRoot) {
1332
+ this.generator = new SourceMapGenerator({ sourceRoot: sourceRoot });
1333
+ this.src = src;
1334
+ this.fragments = stableSort(fragments.slice(0), function(a, b) { return a.start - b.start });
1335
+ this.inFile = inFile || "source.js";
1336
+
1337
+ this.generator.setSourceContent(this.inFile, src);
1338
+ }
1339
+
1340
+ SourceMapper.prototype.generate = function() {
1341
+ var inIndex = 0;
1342
+ var inLine = 1;
1343
+ var inColumn = 0;
1344
+ var outLine = 1;
1345
+ var outColumn = 0;
1346
+ var createMappingAfterWhitespace = true;
1347
+
1348
+ while (inIndex < this.src.length) {
1349
+ if (createMappingAfterWhitespace && !/\s/.test(this.src[inIndex])) {
1350
+ this.addMapping(inLine, inColumn, outLine, outColumn);
1351
+ createMappingAfterWhitespace = false;
1352
+ }
1353
+
1354
+ if (this.fragments[0] && this.fragments[0].start === inIndex) {
1355
+ this.addMapping(inLine, inColumn, outLine, outColumn);
1356
+
1357
+ // iterate over input string
1358
+ for (; inIndex < this.fragments[0].end; inIndex++) {
1359
+ if (this.src[inIndex] === '\n') {
1360
+ inLine++;
1361
+ inColumn = 0;
1362
+ } else {
1363
+ inColumn++;
1364
+ }
1365
+ }
1366
+
1367
+ // iterate over output string
1368
+ for (var outIndex = 0; outIndex < this.fragments[0].str.length; outIndex++) {
1369
+ if (this.fragments[0].str[outIndex] === '\n') {
1370
+ outLine++;
1371
+ outColumn = 0;
1372
+ } else {
1373
+ outColumn++;
1374
+ }
1375
+ }
1376
+
1377
+ this.fragments.shift();
1378
+ createMappingAfterWhitespace = true;
1379
+ }
1380
+
1381
+ else {
1382
+ if (this.src[inIndex] === '\n') {
1383
+ inLine++;
1384
+ outLine++;
1385
+ inColumn = 0;
1386
+ outColumn = 0;
1387
+ createMappingAfterWhitespace = true;
1388
+ } else {
1389
+ inColumn++;
1390
+ outColumn++;
1391
+ }
1392
+ inIndex++;
1393
+ }
1394
+ }
1395
+
1396
+ return this.generator.toString();
1397
+ }
1398
+
1399
+ SourceMapper.prototype.addMapping = function(inLine, inColumn, outLine, outColumn) {
1400
+ this.generator.addMapping({
1401
+ source: this.inFile,
1402
+ original: {
1403
+ line: inLine,
1404
+ column: inColumn
1405
+ },
1406
+ generated: {
1407
+ line: outLine,
1408
+ column: outColumn
1409
+ }
1410
+ });
1411
+ }
1412
+
1413
+ module.exports = function generateSourcemap(src, fragments, inFile, sourceRoot) {
1414
+ return new SourceMapper(src, fragments, inFile, sourceRoot).generate();
1415
+ }
1416
+
1417
+ },{"source-map":19,"stable":29}],9:[function(require,module,exports){
1051
1418
  "use strict";
1052
1419
 
1053
1420
  var assert = require("assert");
@@ -1084,7 +1451,7 @@ function Heap() {
1084
1451
 
1085
1452
  module.exports = Heap;
1086
1453
 
1087
- },{"assert":1,"priorityqueuejs":14}],7:[function(require,module,exports){
1454
+ },{"assert":1,"priorityqueuejs":16}],10:[function(require,module,exports){
1088
1455
  // ng-annotate-main.js
1089
1456
  // MIT licensed, see LICENSE file
1090
1457
  // Copyright (c) 2013-2014 Olov Lassus <olov.lassus@gmail.com>
@@ -1098,6 +1465,7 @@ var alter = require("alter");
1098
1465
  var traverse = require("ordered-ast-traverse");
1099
1466
  var Heap = require("./heap");
1100
1467
  var ngInjectComments = require("./nginject-comments");
1468
+ var generateSourcemap = require("./generate-sourcemap");
1101
1469
 
1102
1470
  var chainedRouteProvider = 1;
1103
1471
  var chainedUrlRouterProvider = 2;
@@ -1291,6 +1659,16 @@ function matchRegular(node, ctx) {
1291
1659
  var obj = callee.object; // identifier or expression
1292
1660
  var method = callee.property; // identifier
1293
1661
 
1662
+ // short-cut implicit config special case:
1663
+ // angular.module("MyMod", function(a) {})
1664
+ if (obj.name === "angular" && method.name === "module") {
1665
+ var args$0 = node.arguments;
1666
+ if (args$0.length >= 2) {
1667
+ last(args$0).$always = true;
1668
+ return last(args$0);
1669
+ }
1670
+ }
1671
+
1294
1672
  var matchAngularModule = (obj.$chained === chainedRegular || isReDef(obj, ctx) || isLongDef(obj)) &&
1295
1673
  is.someof(method.name, ["provider", "value", "constant", "bootstrap", "config", "factory", "directive", "filter", "run", "controller", "service", "decorator", "animation", "invoke"]);
1296
1674
  if (!matchAngularModule) {
@@ -1427,6 +1805,8 @@ function judgeSuspects(ctx) {
1427
1805
  }
1428
1806
  }
1429
1807
 
1808
+ target = jumpOverIife(target);
1809
+
1430
1810
  if (mode === "rebuild" && isAnnotatedArray(target)) {
1431
1811
  replaceArray(target, fragments, quot);
1432
1812
  } else if (mode === "remove" && isAnnotatedArray(target)) {
@@ -1437,6 +1817,18 @@ function judgeSuspects(ctx) {
1437
1817
  }
1438
1818
  }
1439
1819
 
1820
+ function jumpOverIife(node) {
1821
+ var outerfn;
1822
+ var outerbody;
1823
+ if (node.type === "CallExpression" &&
1824
+ (outerfn = node.callee).type === "FunctionExpression" &&
1825
+ (outerbody = outerfn.body.body).length === 1 &&
1826
+ outerbody[0].type === "ReturnStatement" && outerbody[0].argument) {
1827
+ return outerbody[0].argument;
1828
+ }
1829
+ return node;
1830
+ }
1831
+
1440
1832
  function addModuleContextDependentSuspect(target, ctx) {
1441
1833
  ctx.suspects.push(target);
1442
1834
  }
@@ -1589,16 +1981,24 @@ window.annotate = function ngAnnotate(src, options) {
1589
1981
  judgeSuspects(ctx);
1590
1982
 
1591
1983
  var out = alter(src, fragments);
1592
-
1593
- return {
1984
+ var result = {
1594
1985
  src: out,
1595
1986
  _stats: stats,
1596
1987
  };
1988
+
1989
+ if (options.sourcemap) {
1990
+ stats.sourcemap_t0 = Date.now();
1991
+ result.map = generateSourcemap(src, fragments, options.inFile, options.sourceroot);
1992
+ stats.sourcemap_t1 = Date.now();
1993
+ }
1994
+
1995
+ return result;
1597
1996
  }
1598
1997
 
1599
- },{"./heap":6,"./nginject-comments":8,"alter":9,"esprima":11,"ordered-ast-traverse":13,"simple-is":16}],8:[function(require,module,exports){
1998
+ },{"./generate-sourcemap":8,"./heap":9,"./nginject-comments":11,"alter":12,"esprima":13,"ordered-ast-traverse":15,"simple-is":18}],11:[function(require,module,exports){
1600
1999
  "use strict";
1601
2000
 
2001
+ var os = require("os");
1602
2002
  var is = require("simple-is");
1603
2003
  var fmt = require("simple-fmt");
1604
2004
 
@@ -1641,7 +2041,8 @@ function nestedObjectValues(node, res) {
1641
2041
 
1642
2042
  function visitNodeFollowingNgInjectComment(node, ctx) {
1643
2043
  // handle most common case: /*@ngInject*/ prepended to an array or function expression
1644
- if (node.type === "ArrayExpression" || node.type === "FunctionExpression") {
2044
+ // (or call expression, in case of IIFE jumping)
2045
+ if (node.type === "ArrayExpression" || node.type === "FunctionExpression" || node.type === "CallExpression") {
1645
2046
  ctx.addModuleContextIndependentSuspect(node, ctx);
1646
2047
  return;
1647
2048
  }
@@ -1681,7 +2082,7 @@ function visitNodeFollowingNgInjectComment(node, ctx) {
1681
2082
 
1682
2083
  function addRemoveInjectArray(params, posAfterFunctionDeclaration, name) {
1683
2084
  var indent = getIndent(posAfterFunctionDeclaration);
1684
- var str = fmt("\n{0}{1}.$inject = {2};", indent, name, ctx.stringify(params, ctx.quot));
2085
+ var str = fmt("{0}{1}{2}.$inject = {3};", os.EOL, indent, name, ctx.stringify(params, ctx.quot));
1685
2086
 
1686
2087
  ctx.triggers.add({
1687
2088
  pos: posAfterFunctionDeclaration,
@@ -1720,7 +2121,7 @@ function visitNodeFollowingNgInjectComment(node, ctx) {
1720
2121
  }
1721
2122
 
1722
2123
 
1723
- },{"simple-fmt":15,"simple-is":16}],9:[function(require,module,exports){
2124
+ },{"os":5,"simple-fmt":17,"simple-is":18}],12:[function(require,module,exports){
1724
2125
  // alter.js
1725
2126
  // MIT licensed, see LICENSE file
1726
2127
  // Copyright (c) 2013 Olov Lassus <olov.lassus@gmail.com>
@@ -1767,180 +2168,67 @@ if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
1767
2168
  module.exports = alter;
1768
2169
  }
1769
2170
 
1770
- },{"assert":1,"stable":10}],10:[function(require,module,exports){
1771
- //! stable.js 0.1.5, https://github.com/Two-Screen/stable
1772
- //! © 2014 Angry Bytes and contributors. MIT licensed.
1773
-
1774
- (function() {
1775
-
1776
- // A stable array sort, because `Array#sort()` is not guaranteed stable.
1777
- // This is an implementation of merge sort, without recursion.
1778
-
1779
- var stable = function(arr, comp) {
1780
- return exec(arr.slice(), comp);
1781
- };
2171
+ },{"assert":1,"stable":29}],13:[function(require,module,exports){
2172
+ /*
2173
+ Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
2174
+ Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
2175
+ Copyright (C) 2013 Mathias Bynens <mathias@qiwi.be>
2176
+ Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
2177
+ Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
2178
+ Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
2179
+ Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
2180
+ Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
2181
+ Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
2182
+ Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
1782
2183
 
1783
- stable.inplace = function(arr, comp) {
1784
- var result = exec(arr, comp);
2184
+ Redistribution and use in source and binary forms, with or without
2185
+ modification, are permitted provided that the following conditions are met:
1785
2186
 
1786
- // This simply copies back if the result isn't in the original array,
1787
- // which happens on an odd number of passes.
1788
- if (result !== arr) {
1789
- pass(result, null, arr.length, arr);
1790
- }
2187
+ * Redistributions of source code must retain the above copyright
2188
+ notice, this list of conditions and the following disclaimer.
2189
+ * Redistributions in binary form must reproduce the above copyright
2190
+ notice, this list of conditions and the following disclaimer in the
2191
+ documentation and/or other materials provided with the distribution.
1791
2192
 
1792
- return arr;
1793
- };
2193
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
2194
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2195
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2196
+ ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
2197
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
2198
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
2199
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2200
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2201
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2202
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2203
+ */
1794
2204
 
1795
- // Execute the sort using the input array and a second buffer as work space.
1796
- // Returns one of those two, containing the final result.
1797
- function exec(arr, comp) {
1798
- if (typeof(comp) !== 'function') {
1799
- comp = function(a, b) {
1800
- return String(a).localeCompare(b);
1801
- };
1802
- }
2205
+ /*jslint bitwise:true plusplus:true */
2206
+ /*global esprima:true, define:true, exports:true, window: true,
2207
+ throwErrorTolerant: true,
2208
+ throwError: true, generateStatement: true, peek: true,
2209
+ parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
2210
+ parseFunctionDeclaration: true, parseFunctionExpression: true,
2211
+ parseFunctionSourceElements: true, parseVariableIdentifier: true,
2212
+ parseLeftHandSideExpression: true,
2213
+ parseUnaryExpression: true,
2214
+ parseStatement: true, parseSourceElement: true */
1803
2215
 
1804
- // Short-circuit when there's nothing to sort.
1805
- var len = arr.length;
1806
- if (len <= 1) {
1807
- return arr;
1808
- }
2216
+ (function (root, factory) {
2217
+ 'use strict';
1809
2218
 
1810
- // Rather than dividing input, simply iterate chunks of 1, 2, 4, 8, etc.
1811
- // Chunks are the size of the left or right hand in merge sort.
1812
- // Stop when the left-hand covers all of the array.
1813
- var buffer = new Array(len);
1814
- for (var chk = 1; chk < len; chk *= 2) {
1815
- pass(arr, comp, chk, buffer);
2219
+ // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
2220
+ // Rhino, and plain browser loading.
1816
2221
 
1817
- var tmp = arr;
1818
- arr = buffer;
1819
- buffer = tmp;
2222
+ /* istanbul ignore next */
2223
+ if (typeof define === 'function' && define.amd) {
2224
+ define(['exports'], factory);
2225
+ } else if (typeof exports !== 'undefined') {
2226
+ factory(exports);
2227
+ } else {
2228
+ factory((root.esprima = {}));
1820
2229
  }
1821
-
1822
- return arr;
1823
- }
1824
-
1825
- // Run a single pass with the given chunk size.
1826
- var pass = function(arr, comp, chk, result) {
1827
- var len = arr.length;
1828
- var i = 0;
1829
- // Step size / double chunk size.
1830
- var dbl = chk * 2;
1831
- // Bounds of the left and right chunks.
1832
- var l, r, e;
1833
- // Iterators over the left and right chunk.
1834
- var li, ri;
1835
-
1836
- // Iterate over pairs of chunks.
1837
- for (l = 0; l < len; l += dbl) {
1838
- r = l + chk;
1839
- e = r + chk;
1840
- if (r > len) r = len;
1841
- if (e > len) e = len;
1842
-
1843
- // Iterate both chunks in parallel.
1844
- li = l;
1845
- ri = r;
1846
- while (true) {
1847
- // Compare the chunks.
1848
- if (li < r && ri < e) {
1849
- // This works for a regular `sort()` compatible comparator,
1850
- // but also for a simple comparator like: `a > b`
1851
- if (comp(arr[li], arr[ri]) <= 0) {
1852
- result[i++] = arr[li++];
1853
- }
1854
- else {
1855
- result[i++] = arr[ri++];
1856
- }
1857
- }
1858
- // Nothing to compare, just flush what's left.
1859
- else if (li < r) {
1860
- result[i++] = arr[li++];
1861
- }
1862
- else if (ri < e) {
1863
- result[i++] = arr[ri++];
1864
- }
1865
- // Both iterators are at the chunk ends.
1866
- else {
1867
- break;
1868
- }
1869
- }
1870
- }
1871
- };
1872
-
1873
- // Export using CommonJS or to the window.
1874
- if (typeof(module) !== 'undefined') {
1875
- module.exports = stable;
1876
- }
1877
- else {
1878
- window.stable = stable;
1879
- }
1880
-
1881
- })();
1882
-
1883
- },{}],11:[function(require,module,exports){
1884
- /*
1885
- Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
1886
- Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
1887
- Copyright (C) 2013 Mathias Bynens <mathias@qiwi.be>
1888
- Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
1889
- Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
1890
- Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
1891
- Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
1892
- Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
1893
- Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
1894
- Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
1895
-
1896
- Redistribution and use in source and binary forms, with or without
1897
- modification, are permitted provided that the following conditions are met:
1898
-
1899
- * Redistributions of source code must retain the above copyright
1900
- notice, this list of conditions and the following disclaimer.
1901
- * Redistributions in binary form must reproduce the above copyright
1902
- notice, this list of conditions and the following disclaimer in the
1903
- documentation and/or other materials provided with the distribution.
1904
-
1905
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1906
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1907
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1908
- ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
1909
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
1910
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
1911
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
1912
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1913
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
1914
- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1915
- */
1916
-
1917
- /*jslint bitwise:true plusplus:true */
1918
- /*global esprima:true, define:true, exports:true, window: true,
1919
- throwErrorTolerant: true,
1920
- throwError: true, generateStatement: true, peek: true,
1921
- parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
1922
- parseFunctionDeclaration: true, parseFunctionExpression: true,
1923
- parseFunctionSourceElements: true, parseVariableIdentifier: true,
1924
- parseLeftHandSideExpression: true,
1925
- parseUnaryExpression: true,
1926
- parseStatement: true, parseSourceElement: true */
1927
-
1928
- (function (root, factory) {
1929
- 'use strict';
1930
-
1931
- // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
1932
- // Rhino, and plain browser loading.
1933
-
1934
- /* istanbul ignore next */
1935
- if (typeof define === 'function' && define.amd) {
1936
- define(['exports'], factory);
1937
- } else if (typeof exports !== 'undefined') {
1938
- factory(exports);
1939
- } else {
1940
- factory((root.esprima = {}));
1941
- }
1942
- }(this, function (exports) {
1943
- 'use strict';
2230
+ }(this, function (exports) {
2231
+ 'use strict';
1944
2232
 
1945
2233
  var Token,
1946
2234
  TokenName,
@@ -5638,7 +5926,7 @@ parseStatement: true, parseSourceElement: true */
5638
5926
  }));
5639
5927
  /* vim: set sw=4 ts=4 et tw=80 : */
5640
5928
 
5641
- },{}],12:[function(require,module,exports){
5929
+ },{}],14:[function(require,module,exports){
5642
5930
  // ordered-esprima-props.js
5643
5931
  // MIT licensed, see LICENSE file
5644
5932
  // Copyright (c) 2014 Olov Lassus <olov.lassus@gmail.com>
@@ -5717,7 +6005,7 @@ module.exports = (function() {
5717
6005
  };
5718
6006
  })();
5719
6007
 
5720
- },{}],13:[function(require,module,exports){
6008
+ },{}],15:[function(require,module,exports){
5721
6009
  // ordered-ast-traverse.js
5722
6010
  // MIT licensed, see LICENSE file
5723
6011
  // Copyright (c) 2014 Olov Lassus <olov.lassus@gmail.com>
@@ -5778,7 +6066,7 @@ if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
5778
6066
  module.exports = traverse;
5779
6067
  }
5780
6068
 
5781
- },{"ordered-esprima-props":12}],14:[function(require,module,exports){
6069
+ },{"ordered-esprima-props":14}],16:[function(require,module,exports){
5782
6070
  /**
5783
6071
  * Expose `PriorityQueue`.
5784
6072
  */
@@ -5952,7 +6240,7 @@ PriorityQueue.prototype._swap = function(a, b) {
5952
6240
  this._elements[b] = aux;
5953
6241
  };
5954
6242
 
5955
- },{}],15:[function(require,module,exports){
6243
+ },{}],17:[function(require,module,exports){
5956
6244
  // simple-fmt.js
5957
6245
  // MIT licensed, see LICENSE file
5958
6246
  // Copyright (c) 2013 Olov Lassus <olov.lassus@gmail.com>
@@ -5987,7 +6275,7 @@ if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
5987
6275
  module.exports = fmt;
5988
6276
  }
5989
6277
 
5990
- },{}],16:[function(require,module,exports){
6278
+ },{}],18:[function(require,module,exports){
5991
6279
  // simple-is.js
5992
6280
  // MIT licensed, see LICENSE file
5993
6281
  // Copyright (c) 2013 Olov Lassus <olov.lassus@gmail.com>
@@ -6045,4 +6333,2418 @@ if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
6045
6333
  module.exports = is;
6046
6334
  }
6047
6335
 
6048
- },{}]},{},[7])
6336
+ },{}],19:[function(require,module,exports){
6337
+ /*
6338
+ * Copyright 2009-2011 Mozilla Foundation and contributors
6339
+ * Licensed under the New BSD license. See LICENSE.txt or:
6340
+ * http://opensource.org/licenses/BSD-3-Clause
6341
+ */
6342
+ exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
6343
+ exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
6344
+ exports.SourceNode = require('./source-map/source-node').SourceNode;
6345
+
6346
+ },{"./source-map/source-map-consumer":24,"./source-map/source-map-generator":25,"./source-map/source-node":26}],20:[function(require,module,exports){
6347
+ /* -*- Mode: js; js-indent-level: 2; -*- */
6348
+ /*
6349
+ * Copyright 2011 Mozilla Foundation and contributors
6350
+ * Licensed under the New BSD license. See LICENSE or:
6351
+ * http://opensource.org/licenses/BSD-3-Clause
6352
+ */
6353
+ if (typeof define !== 'function') {
6354
+ var define = require('amdefine')(module, require);
6355
+ }
6356
+ define(function (require, exports, module) {
6357
+
6358
+ var util = require('./util');
6359
+
6360
+ /**
6361
+ * A data structure which is a combination of an array and a set. Adding a new
6362
+ * member is O(1), testing for membership is O(1), and finding the index of an
6363
+ * element is O(1). Removing elements from the set is not supported. Only
6364
+ * strings are supported for membership.
6365
+ */
6366
+ function ArraySet() {
6367
+ this._array = [];
6368
+ this._set = {};
6369
+ }
6370
+
6371
+ /**
6372
+ * Static method for creating ArraySet instances from an existing array.
6373
+ */
6374
+ ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
6375
+ var set = new ArraySet();
6376
+ for (var i = 0, len = aArray.length; i < len; i++) {
6377
+ set.add(aArray[i], aAllowDuplicates);
6378
+ }
6379
+ return set;
6380
+ };
6381
+
6382
+ /**
6383
+ * Add the given string to this set.
6384
+ *
6385
+ * @param String aStr
6386
+ */
6387
+ ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
6388
+ var isDuplicate = this.has(aStr);
6389
+ var idx = this._array.length;
6390
+ if (!isDuplicate || aAllowDuplicates) {
6391
+ this._array.push(aStr);
6392
+ }
6393
+ if (!isDuplicate) {
6394
+ this._set[util.toSetString(aStr)] = idx;
6395
+ }
6396
+ };
6397
+
6398
+ /**
6399
+ * Is the given string a member of this set?
6400
+ *
6401
+ * @param String aStr
6402
+ */
6403
+ ArraySet.prototype.has = function ArraySet_has(aStr) {
6404
+ return Object.prototype.hasOwnProperty.call(this._set,
6405
+ util.toSetString(aStr));
6406
+ };
6407
+
6408
+ /**
6409
+ * What is the index of the given string in the array?
6410
+ *
6411
+ * @param String aStr
6412
+ */
6413
+ ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
6414
+ if (this.has(aStr)) {
6415
+ return this._set[util.toSetString(aStr)];
6416
+ }
6417
+ throw new Error('"' + aStr + '" is not in the set.');
6418
+ };
6419
+
6420
+ /**
6421
+ * What is the element at the given index?
6422
+ *
6423
+ * @param Number aIdx
6424
+ */
6425
+ ArraySet.prototype.at = function ArraySet_at(aIdx) {
6426
+ if (aIdx >= 0 && aIdx < this._array.length) {
6427
+ return this._array[aIdx];
6428
+ }
6429
+ throw new Error('No element indexed by ' + aIdx);
6430
+ };
6431
+
6432
+ /**
6433
+ * Returns the array representation of this set (which has the proper indices
6434
+ * indicated by indexOf). Note that this is a copy of the internal array used
6435
+ * for storing the members so that no one can mess with internal state.
6436
+ */
6437
+ ArraySet.prototype.toArray = function ArraySet_toArray() {
6438
+ return this._array.slice();
6439
+ };
6440
+
6441
+ exports.ArraySet = ArraySet;
6442
+
6443
+ });
6444
+
6445
+ },{"./util":27,"amdefine":28}],21:[function(require,module,exports){
6446
+ /* -*- Mode: js; js-indent-level: 2; -*- */
6447
+ /*
6448
+ * Copyright 2011 Mozilla Foundation and contributors
6449
+ * Licensed under the New BSD license. See LICENSE or:
6450
+ * http://opensource.org/licenses/BSD-3-Clause
6451
+ *
6452
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
6453
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
6454
+ *
6455
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
6456
+ * Redistribution and use in source and binary forms, with or without
6457
+ * modification, are permitted provided that the following conditions are
6458
+ * met:
6459
+ *
6460
+ * * Redistributions of source code must retain the above copyright
6461
+ * notice, this list of conditions and the following disclaimer.
6462
+ * * Redistributions in binary form must reproduce the above
6463
+ * copyright notice, this list of conditions and the following
6464
+ * disclaimer in the documentation and/or other materials provided
6465
+ * with the distribution.
6466
+ * * Neither the name of Google Inc. nor the names of its
6467
+ * contributors may be used to endorse or promote products derived
6468
+ * from this software without specific prior written permission.
6469
+ *
6470
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
6471
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
6472
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6473
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
6474
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
6475
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
6476
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
6477
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
6478
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
6479
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
6480
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
6481
+ */
6482
+ if (typeof define !== 'function') {
6483
+ var define = require('amdefine')(module, require);
6484
+ }
6485
+ define(function (require, exports, module) {
6486
+
6487
+ var base64 = require('./base64');
6488
+
6489
+ // A single base 64 digit can contain 6 bits of data. For the base 64 variable
6490
+ // length quantities we use in the source map spec, the first bit is the sign,
6491
+ // the next four bits are the actual value, and the 6th bit is the
6492
+ // continuation bit. The continuation bit tells us whether there are more
6493
+ // digits in this value following this digit.
6494
+ //
6495
+ // Continuation
6496
+ // | Sign
6497
+ // | |
6498
+ // V V
6499
+ // 101011
6500
+
6501
+ var VLQ_BASE_SHIFT = 5;
6502
+
6503
+ // binary: 100000
6504
+ var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
6505
+
6506
+ // binary: 011111
6507
+ var VLQ_BASE_MASK = VLQ_BASE - 1;
6508
+
6509
+ // binary: 100000
6510
+ var VLQ_CONTINUATION_BIT = VLQ_BASE;
6511
+
6512
+ /**
6513
+ * Converts from a two-complement value to a value where the sign bit is
6514
+ * is placed in the least significant bit. For example, as decimals:
6515
+ * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
6516
+ * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
6517
+ */
6518
+ function toVLQSigned(aValue) {
6519
+ return aValue < 0
6520
+ ? ((-aValue) << 1) + 1
6521
+ : (aValue << 1) + 0;
6522
+ }
6523
+
6524
+ /**
6525
+ * Converts to a two-complement value from a value where the sign bit is
6526
+ * is placed in the least significant bit. For example, as decimals:
6527
+ * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
6528
+ * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
6529
+ */
6530
+ function fromVLQSigned(aValue) {
6531
+ var isNegative = (aValue & 1) === 1;
6532
+ var shifted = aValue >> 1;
6533
+ return isNegative
6534
+ ? -shifted
6535
+ : shifted;
6536
+ }
6537
+
6538
+ /**
6539
+ * Returns the base 64 VLQ encoded value.
6540
+ */
6541
+ exports.encode = function base64VLQ_encode(aValue) {
6542
+ var encoded = "";
6543
+ var digit;
6544
+
6545
+ var vlq = toVLQSigned(aValue);
6546
+
6547
+ do {
6548
+ digit = vlq & VLQ_BASE_MASK;
6549
+ vlq >>>= VLQ_BASE_SHIFT;
6550
+ if (vlq > 0) {
6551
+ // There are still more digits in this value, so we must make sure the
6552
+ // continuation bit is marked.
6553
+ digit |= VLQ_CONTINUATION_BIT;
6554
+ }
6555
+ encoded += base64.encode(digit);
6556
+ } while (vlq > 0);
6557
+
6558
+ return encoded;
6559
+ };
6560
+
6561
+ /**
6562
+ * Decodes the next base 64 VLQ value from the given string and returns the
6563
+ * value and the rest of the string.
6564
+ */
6565
+ exports.decode = function base64VLQ_decode(aStr) {
6566
+ var i = 0;
6567
+ var strLen = aStr.length;
6568
+ var result = 0;
6569
+ var shift = 0;
6570
+ var continuation, digit;
6571
+
6572
+ do {
6573
+ if (i >= strLen) {
6574
+ throw new Error("Expected more digits in base 64 VLQ value.");
6575
+ }
6576
+ digit = base64.decode(aStr.charAt(i++));
6577
+ continuation = !!(digit & VLQ_CONTINUATION_BIT);
6578
+ digit &= VLQ_BASE_MASK;
6579
+ result = result + (digit << shift);
6580
+ shift += VLQ_BASE_SHIFT;
6581
+ } while (continuation);
6582
+
6583
+ return {
6584
+ value: fromVLQSigned(result),
6585
+ rest: aStr.slice(i)
6586
+ };
6587
+ };
6588
+
6589
+ });
6590
+
6591
+ },{"./base64":22,"amdefine":28}],22:[function(require,module,exports){
6592
+ /* -*- Mode: js; js-indent-level: 2; -*- */
6593
+ /*
6594
+ * Copyright 2011 Mozilla Foundation and contributors
6595
+ * Licensed under the New BSD license. See LICENSE or:
6596
+ * http://opensource.org/licenses/BSD-3-Clause
6597
+ */
6598
+ if (typeof define !== 'function') {
6599
+ var define = require('amdefine')(module, require);
6600
+ }
6601
+ define(function (require, exports, module) {
6602
+
6603
+ var charToIntMap = {};
6604
+ var intToCharMap = {};
6605
+
6606
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
6607
+ .split('')
6608
+ .forEach(function (ch, index) {
6609
+ charToIntMap[ch] = index;
6610
+ intToCharMap[index] = ch;
6611
+ });
6612
+
6613
+ /**
6614
+ * Encode an integer in the range of 0 to 63 to a single base 64 digit.
6615
+ */
6616
+ exports.encode = function base64_encode(aNumber) {
6617
+ if (aNumber in intToCharMap) {
6618
+ return intToCharMap[aNumber];
6619
+ }
6620
+ throw new TypeError("Must be between 0 and 63: " + aNumber);
6621
+ };
6622
+
6623
+ /**
6624
+ * Decode a single base 64 digit to an integer.
6625
+ */
6626
+ exports.decode = function base64_decode(aChar) {
6627
+ if (aChar in charToIntMap) {
6628
+ return charToIntMap[aChar];
6629
+ }
6630
+ throw new TypeError("Not a valid base 64 digit: " + aChar);
6631
+ };
6632
+
6633
+ });
6634
+
6635
+ },{"amdefine":28}],23:[function(require,module,exports){
6636
+ /* -*- Mode: js; js-indent-level: 2; -*- */
6637
+ /*
6638
+ * Copyright 2011 Mozilla Foundation and contributors
6639
+ * Licensed under the New BSD license. See LICENSE or:
6640
+ * http://opensource.org/licenses/BSD-3-Clause
6641
+ */
6642
+ if (typeof define !== 'function') {
6643
+ var define = require('amdefine')(module, require);
6644
+ }
6645
+ define(function (require, exports, module) {
6646
+
6647
+ /**
6648
+ * Recursive implementation of binary search.
6649
+ *
6650
+ * @param aLow Indices here and lower do not contain the needle.
6651
+ * @param aHigh Indices here and higher do not contain the needle.
6652
+ * @param aNeedle The element being searched for.
6653
+ * @param aHaystack The non-empty array being searched.
6654
+ * @param aCompare Function which takes two elements and returns -1, 0, or 1.
6655
+ */
6656
+ function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
6657
+ // This function terminates when one of the following is true:
6658
+ //
6659
+ // 1. We find the exact element we are looking for.
6660
+ //
6661
+ // 2. We did not find the exact element, but we can return the next
6662
+ // closest element that is less than that element.
6663
+ //
6664
+ // 3. We did not find the exact element, and there is no next-closest
6665
+ // element which is less than the one we are searching for, so we
6666
+ // return null.
6667
+ var mid = Math.floor((aHigh - aLow) / 2) + aLow;
6668
+ var cmp = aCompare(aNeedle, aHaystack[mid], true);
6669
+ if (cmp === 0) {
6670
+ // Found the element we are looking for.
6671
+ return aHaystack[mid];
6672
+ }
6673
+ else if (cmp > 0) {
6674
+ // aHaystack[mid] is greater than our needle.
6675
+ if (aHigh - mid > 1) {
6676
+ // The element is in the upper half.
6677
+ return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
6678
+ }
6679
+ // We did not find an exact match, return the next closest one
6680
+ // (termination case 2).
6681
+ return aHaystack[mid];
6682
+ }
6683
+ else {
6684
+ // aHaystack[mid] is less than our needle.
6685
+ if (mid - aLow > 1) {
6686
+ // The element is in the lower half.
6687
+ return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
6688
+ }
6689
+ // The exact needle element was not found in this haystack. Determine if
6690
+ // we are in termination case (2) or (3) and return the appropriate thing.
6691
+ return aLow < 0
6692
+ ? null
6693
+ : aHaystack[aLow];
6694
+ }
6695
+ }
6696
+
6697
+ /**
6698
+ * This is an implementation of binary search which will always try and return
6699
+ * the next lowest value checked if there is no exact hit. This is because
6700
+ * mappings between original and generated line/col pairs are single points,
6701
+ * and there is an implicit region between each of them, so a miss just means
6702
+ * that you aren't on the very start of a region.
6703
+ *
6704
+ * @param aNeedle The element you are looking for.
6705
+ * @param aHaystack The array that is being searched.
6706
+ * @param aCompare A function which takes the needle and an element in the
6707
+ * array and returns -1, 0, or 1 depending on whether the needle is less
6708
+ * than, equal to, or greater than the element, respectively.
6709
+ */
6710
+ exports.search = function search(aNeedle, aHaystack, aCompare) {
6711
+ return aHaystack.length > 0
6712
+ ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
6713
+ : null;
6714
+ };
6715
+
6716
+ });
6717
+
6718
+ },{"amdefine":28}],24:[function(require,module,exports){
6719
+ /* -*- Mode: js; js-indent-level: 2; -*- */
6720
+ /*
6721
+ * Copyright 2011 Mozilla Foundation and contributors
6722
+ * Licensed under the New BSD license. See LICENSE or:
6723
+ * http://opensource.org/licenses/BSD-3-Clause
6724
+ */
6725
+ if (typeof define !== 'function') {
6726
+ var define = require('amdefine')(module, require);
6727
+ }
6728
+ define(function (require, exports, module) {
6729
+
6730
+ var util = require('./util');
6731
+ var binarySearch = require('./binary-search');
6732
+ var ArraySet = require('./array-set').ArraySet;
6733
+ var base64VLQ = require('./base64-vlq');
6734
+
6735
+ /**
6736
+ * A SourceMapConsumer instance represents a parsed source map which we can
6737
+ * query for information about the original file positions by giving it a file
6738
+ * position in the generated source.
6739
+ *
6740
+ * The only parameter is the raw source map (either as a JSON string, or
6741
+ * already parsed to an object). According to the spec, source maps have the
6742
+ * following attributes:
6743
+ *
6744
+ * - version: Which version of the source map spec this map is following.
6745
+ * - sources: An array of URLs to the original source files.
6746
+ * - names: An array of identifiers which can be referrenced by individual mappings.
6747
+ * - sourceRoot: Optional. The URL root from which all sources are relative.
6748
+ * - sourcesContent: Optional. An array of contents of the original source files.
6749
+ * - mappings: A string of base64 VLQs which contain the actual mappings.
6750
+ * - file: Optional. The generated file this source map is associated with.
6751
+ *
6752
+ * Here is an example source map, taken from the source map spec[0]:
6753
+ *
6754
+ * {
6755
+ * version : 3,
6756
+ * file: "out.js",
6757
+ * sourceRoot : "",
6758
+ * sources: ["foo.js", "bar.js"],
6759
+ * names: ["src", "maps", "are", "fun"],
6760
+ * mappings: "AA,AB;;ABCDE;"
6761
+ * }
6762
+ *
6763
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
6764
+ */
6765
+ function SourceMapConsumer(aSourceMap) {
6766
+ var sourceMap = aSourceMap;
6767
+ if (typeof aSourceMap === 'string') {
6768
+ sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
6769
+ }
6770
+
6771
+ var version = util.getArg(sourceMap, 'version');
6772
+ var sources = util.getArg(sourceMap, 'sources');
6773
+ // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
6774
+ // requires the array) to play nice here.
6775
+ var names = util.getArg(sourceMap, 'names', []);
6776
+ var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
6777
+ var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
6778
+ var mappings = util.getArg(sourceMap, 'mappings');
6779
+ var file = util.getArg(sourceMap, 'file', null);
6780
+
6781
+ // Once again, Sass deviates from the spec and supplies the version as a
6782
+ // string rather than a number, so we use loose equality checking here.
6783
+ if (version != this._version) {
6784
+ throw new Error('Unsupported version: ' + version);
6785
+ }
6786
+
6787
+ // Pass `true` below to allow duplicate names and sources. While source maps
6788
+ // are intended to be compressed and deduplicated, the TypeScript compiler
6789
+ // sometimes generates source maps with duplicates in them. See Github issue
6790
+ // #72 and bugzil.la/889492.
6791
+ this._names = ArraySet.fromArray(names, true);
6792
+ this._sources = ArraySet.fromArray(sources, true);
6793
+
6794
+ this.sourceRoot = sourceRoot;
6795
+ this.sourcesContent = sourcesContent;
6796
+ this._mappings = mappings;
6797
+ this.file = file;
6798
+ }
6799
+
6800
+ /**
6801
+ * Create a SourceMapConsumer from a SourceMapGenerator.
6802
+ *
6803
+ * @param SourceMapGenerator aSourceMap
6804
+ * The source map that will be consumed.
6805
+ * @returns SourceMapConsumer
6806
+ */
6807
+ SourceMapConsumer.fromSourceMap =
6808
+ function SourceMapConsumer_fromSourceMap(aSourceMap) {
6809
+ var smc = Object.create(SourceMapConsumer.prototype);
6810
+
6811
+ smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
6812
+ smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
6813
+ smc.sourceRoot = aSourceMap._sourceRoot;
6814
+ smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
6815
+ smc.sourceRoot);
6816
+ smc.file = aSourceMap._file;
6817
+
6818
+ smc.__generatedMappings = aSourceMap._mappings.slice()
6819
+ .sort(util.compareByGeneratedPositions);
6820
+ smc.__originalMappings = aSourceMap._mappings.slice()
6821
+ .sort(util.compareByOriginalPositions);
6822
+
6823
+ return smc;
6824
+ };
6825
+
6826
+ /**
6827
+ * The version of the source mapping spec that we are consuming.
6828
+ */
6829
+ SourceMapConsumer.prototype._version = 3;
6830
+
6831
+ /**
6832
+ * The list of original sources.
6833
+ */
6834
+ Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
6835
+ get: function () {
6836
+ return this._sources.toArray().map(function (s) {
6837
+ return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
6838
+ }, this);
6839
+ }
6840
+ });
6841
+
6842
+ // `__generatedMappings` and `__originalMappings` are arrays that hold the
6843
+ // parsed mapping coordinates from the source map's "mappings" attribute. They
6844
+ // are lazily instantiated, accessed via the `_generatedMappings` and
6845
+ // `_originalMappings` getters respectively, and we only parse the mappings
6846
+ // and create these arrays once queried for a source location. We jump through
6847
+ // these hoops because there can be many thousands of mappings, and parsing
6848
+ // them is expensive, so we only want to do it if we must.
6849
+ //
6850
+ // Each object in the arrays is of the form:
6851
+ //
6852
+ // {
6853
+ // generatedLine: The line number in the generated code,
6854
+ // generatedColumn: The column number in the generated code,
6855
+ // source: The path to the original source file that generated this
6856
+ // chunk of code,
6857
+ // originalLine: The line number in the original source that
6858
+ // corresponds to this chunk of generated code,
6859
+ // originalColumn: The column number in the original source that
6860
+ // corresponds to this chunk of generated code,
6861
+ // name: The name of the original symbol which generated this chunk of
6862
+ // code.
6863
+ // }
6864
+ //
6865
+ // All properties except for `generatedLine` and `generatedColumn` can be
6866
+ // `null`.
6867
+ //
6868
+ // `_generatedMappings` is ordered by the generated positions.
6869
+ //
6870
+ // `_originalMappings` is ordered by the original positions.
6871
+
6872
+ SourceMapConsumer.prototype.__generatedMappings = null;
6873
+ Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
6874
+ get: function () {
6875
+ if (!this.__generatedMappings) {
6876
+ this.__generatedMappings = [];
6877
+ this.__originalMappings = [];
6878
+ this._parseMappings(this._mappings, this.sourceRoot);
6879
+ }
6880
+
6881
+ return this.__generatedMappings;
6882
+ }
6883
+ });
6884
+
6885
+ SourceMapConsumer.prototype.__originalMappings = null;
6886
+ Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
6887
+ get: function () {
6888
+ if (!this.__originalMappings) {
6889
+ this.__generatedMappings = [];
6890
+ this.__originalMappings = [];
6891
+ this._parseMappings(this._mappings, this.sourceRoot);
6892
+ }
6893
+
6894
+ return this.__originalMappings;
6895
+ }
6896
+ });
6897
+
6898
+ /**
6899
+ * Parse the mappings in a string in to a data structure which we can easily
6900
+ * query (the ordered arrays in the `this.__generatedMappings` and
6901
+ * `this.__originalMappings` properties).
6902
+ */
6903
+ SourceMapConsumer.prototype._parseMappings =
6904
+ function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
6905
+ var generatedLine = 1;
6906
+ var previousGeneratedColumn = 0;
6907
+ var previousOriginalLine = 0;
6908
+ var previousOriginalColumn = 0;
6909
+ var previousSource = 0;
6910
+ var previousName = 0;
6911
+ var mappingSeparator = /^[,;]/;
6912
+ var str = aStr;
6913
+ var mapping;
6914
+ var temp;
6915
+
6916
+ while (str.length > 0) {
6917
+ if (str.charAt(0) === ';') {
6918
+ generatedLine++;
6919
+ str = str.slice(1);
6920
+ previousGeneratedColumn = 0;
6921
+ }
6922
+ else if (str.charAt(0) === ',') {
6923
+ str = str.slice(1);
6924
+ }
6925
+ else {
6926
+ mapping = {};
6927
+ mapping.generatedLine = generatedLine;
6928
+
6929
+ // Generated column.
6930
+ temp = base64VLQ.decode(str);
6931
+ mapping.generatedColumn = previousGeneratedColumn + temp.value;
6932
+ previousGeneratedColumn = mapping.generatedColumn;
6933
+ str = temp.rest;
6934
+
6935
+ if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
6936
+ // Original source.
6937
+ temp = base64VLQ.decode(str);
6938
+ mapping.source = this._sources.at(previousSource + temp.value);
6939
+ previousSource += temp.value;
6940
+ str = temp.rest;
6941
+ if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
6942
+ throw new Error('Found a source, but no line and column');
6943
+ }
6944
+
6945
+ // Original line.
6946
+ temp = base64VLQ.decode(str);
6947
+ mapping.originalLine = previousOriginalLine + temp.value;
6948
+ previousOriginalLine = mapping.originalLine;
6949
+ // Lines are stored 0-based
6950
+ mapping.originalLine += 1;
6951
+ str = temp.rest;
6952
+ if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
6953
+ throw new Error('Found a source and line, but no column');
6954
+ }
6955
+
6956
+ // Original column.
6957
+ temp = base64VLQ.decode(str);
6958
+ mapping.originalColumn = previousOriginalColumn + temp.value;
6959
+ previousOriginalColumn = mapping.originalColumn;
6960
+ str = temp.rest;
6961
+
6962
+ if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
6963
+ // Original name.
6964
+ temp = base64VLQ.decode(str);
6965
+ mapping.name = this._names.at(previousName + temp.value);
6966
+ previousName += temp.value;
6967
+ str = temp.rest;
6968
+ }
6969
+ }
6970
+
6971
+ this.__generatedMappings.push(mapping);
6972
+ if (typeof mapping.originalLine === 'number') {
6973
+ this.__originalMappings.push(mapping);
6974
+ }
6975
+ }
6976
+ }
6977
+
6978
+ this.__generatedMappings.sort(util.compareByGeneratedPositions);
6979
+ this.__originalMappings.sort(util.compareByOriginalPositions);
6980
+ };
6981
+
6982
+ /**
6983
+ * Find the mapping that best matches the hypothetical "needle" mapping that
6984
+ * we are searching for in the given "haystack" of mappings.
6985
+ */
6986
+ SourceMapConsumer.prototype._findMapping =
6987
+ function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
6988
+ aColumnName, aComparator) {
6989
+ // To return the position we are searching for, we must first find the
6990
+ // mapping for the given position and then return the opposite position it
6991
+ // points to. Because the mappings are sorted, we can use binary search to
6992
+ // find the best mapping.
6993
+
6994
+ if (aNeedle[aLineName] <= 0) {
6995
+ throw new TypeError('Line must be greater than or equal to 1, got '
6996
+ + aNeedle[aLineName]);
6997
+ }
6998
+ if (aNeedle[aColumnName] < 0) {
6999
+ throw new TypeError('Column must be greater than or equal to 0, got '
7000
+ + aNeedle[aColumnName]);
7001
+ }
7002
+
7003
+ return binarySearch.search(aNeedle, aMappings, aComparator);
7004
+ };
7005
+
7006
+ /**
7007
+ * Returns the original source, line, and column information for the generated
7008
+ * source's line and column positions provided. The only argument is an object
7009
+ * with the following properties:
7010
+ *
7011
+ * - line: The line number in the generated source.
7012
+ * - column: The column number in the generated source.
7013
+ *
7014
+ * and an object is returned with the following properties:
7015
+ *
7016
+ * - source: The original source file, or null.
7017
+ * - line: The line number in the original source, or null.
7018
+ * - column: The column number in the original source, or null.
7019
+ * - name: The original identifier, or null.
7020
+ */
7021
+ SourceMapConsumer.prototype.originalPositionFor =
7022
+ function SourceMapConsumer_originalPositionFor(aArgs) {
7023
+ var needle = {
7024
+ generatedLine: util.getArg(aArgs, 'line'),
7025
+ generatedColumn: util.getArg(aArgs, 'column')
7026
+ };
7027
+
7028
+ var mapping = this._findMapping(needle,
7029
+ this._generatedMappings,
7030
+ "generatedLine",
7031
+ "generatedColumn",
7032
+ util.compareByGeneratedPositions);
7033
+
7034
+ if (mapping && mapping.generatedLine === needle.generatedLine) {
7035
+ var source = util.getArg(mapping, 'source', null);
7036
+ if (source != null && this.sourceRoot != null) {
7037
+ source = util.join(this.sourceRoot, source);
7038
+ }
7039
+ return {
7040
+ source: source,
7041
+ line: util.getArg(mapping, 'originalLine', null),
7042
+ column: util.getArg(mapping, 'originalColumn', null),
7043
+ name: util.getArg(mapping, 'name', null)
7044
+ };
7045
+ }
7046
+
7047
+ return {
7048
+ source: null,
7049
+ line: null,
7050
+ column: null,
7051
+ name: null
7052
+ };
7053
+ };
7054
+
7055
+ /**
7056
+ * Returns the original source content. The only argument is the url of the
7057
+ * original source file. Returns null if no original source content is
7058
+ * availible.
7059
+ */
7060
+ SourceMapConsumer.prototype.sourceContentFor =
7061
+ function SourceMapConsumer_sourceContentFor(aSource) {
7062
+ if (!this.sourcesContent) {
7063
+ return null;
7064
+ }
7065
+
7066
+ if (this.sourceRoot != null) {
7067
+ aSource = util.relative(this.sourceRoot, aSource);
7068
+ }
7069
+
7070
+ if (this._sources.has(aSource)) {
7071
+ return this.sourcesContent[this._sources.indexOf(aSource)];
7072
+ }
7073
+
7074
+ var url;
7075
+ if (this.sourceRoot != null
7076
+ && (url = util.urlParse(this.sourceRoot))) {
7077
+ // XXX: file:// URIs and absolute paths lead to unexpected behavior for
7078
+ // many users. We can help them out when they expect file:// URIs to
7079
+ // behave like it would if they were running a local HTTP server. See
7080
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
7081
+ var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
7082
+ if (url.scheme == "file"
7083
+ && this._sources.has(fileUriAbsPath)) {
7084
+ return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
7085
+ }
7086
+
7087
+ if ((!url.path || url.path == "/")
7088
+ && this._sources.has("/" + aSource)) {
7089
+ return this.sourcesContent[this._sources.indexOf("/" + aSource)];
7090
+ }
7091
+ }
7092
+
7093
+ throw new Error('"' + aSource + '" is not in the SourceMap.');
7094
+ };
7095
+
7096
+ /**
7097
+ * Returns the generated line and column information for the original source,
7098
+ * line, and column positions provided. The only argument is an object with
7099
+ * the following properties:
7100
+ *
7101
+ * - source: The filename of the original source.
7102
+ * - line: The line number in the original source.
7103
+ * - column: The column number in the original source.
7104
+ *
7105
+ * and an object is returned with the following properties:
7106
+ *
7107
+ * - line: The line number in the generated source, or null.
7108
+ * - column: The column number in the generated source, or null.
7109
+ */
7110
+ SourceMapConsumer.prototype.generatedPositionFor =
7111
+ function SourceMapConsumer_generatedPositionFor(aArgs) {
7112
+ var needle = {
7113
+ source: util.getArg(aArgs, 'source'),
7114
+ originalLine: util.getArg(aArgs, 'line'),
7115
+ originalColumn: util.getArg(aArgs, 'column')
7116
+ };
7117
+
7118
+ if (this.sourceRoot != null) {
7119
+ needle.source = util.relative(this.sourceRoot, needle.source);
7120
+ }
7121
+
7122
+ var mapping = this._findMapping(needle,
7123
+ this._originalMappings,
7124
+ "originalLine",
7125
+ "originalColumn",
7126
+ util.compareByOriginalPositions);
7127
+
7128
+ if (mapping) {
7129
+ return {
7130
+ line: util.getArg(mapping, 'generatedLine', null),
7131
+ column: util.getArg(mapping, 'generatedColumn', null)
7132
+ };
7133
+ }
7134
+
7135
+ return {
7136
+ line: null,
7137
+ column: null
7138
+ };
7139
+ };
7140
+
7141
+ SourceMapConsumer.GENERATED_ORDER = 1;
7142
+ SourceMapConsumer.ORIGINAL_ORDER = 2;
7143
+
7144
+ /**
7145
+ * Iterate over each mapping between an original source/line/column and a
7146
+ * generated line/column in this source map.
7147
+ *
7148
+ * @param Function aCallback
7149
+ * The function that is called with each mapping.
7150
+ * @param Object aContext
7151
+ * Optional. If specified, this object will be the value of `this` every
7152
+ * time that `aCallback` is called.
7153
+ * @param aOrder
7154
+ * Either `SourceMapConsumer.GENERATED_ORDER` or
7155
+ * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
7156
+ * iterate over the mappings sorted by the generated file's line/column
7157
+ * order or the original's source/line/column order, respectively. Defaults to
7158
+ * `SourceMapConsumer.GENERATED_ORDER`.
7159
+ */
7160
+ SourceMapConsumer.prototype.eachMapping =
7161
+ function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
7162
+ var context = aContext || null;
7163
+ var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
7164
+
7165
+ var mappings;
7166
+ switch (order) {
7167
+ case SourceMapConsumer.GENERATED_ORDER:
7168
+ mappings = this._generatedMappings;
7169
+ break;
7170
+ case SourceMapConsumer.ORIGINAL_ORDER:
7171
+ mappings = this._originalMappings;
7172
+ break;
7173
+ default:
7174
+ throw new Error("Unknown order of iteration.");
7175
+ }
7176
+
7177
+ var sourceRoot = this.sourceRoot;
7178
+ mappings.map(function (mapping) {
7179
+ var source = mapping.source;
7180
+ if (source != null && sourceRoot != null) {
7181
+ source = util.join(sourceRoot, source);
7182
+ }
7183
+ return {
7184
+ source: source,
7185
+ generatedLine: mapping.generatedLine,
7186
+ generatedColumn: mapping.generatedColumn,
7187
+ originalLine: mapping.originalLine,
7188
+ originalColumn: mapping.originalColumn,
7189
+ name: mapping.name
7190
+ };
7191
+ }).forEach(aCallback, context);
7192
+ };
7193
+
7194
+ exports.SourceMapConsumer = SourceMapConsumer;
7195
+
7196
+ });
7197
+
7198
+ },{"./array-set":20,"./base64-vlq":21,"./binary-search":23,"./util":27,"amdefine":28}],25:[function(require,module,exports){
7199
+ /* -*- Mode: js; js-indent-level: 2; -*- */
7200
+ /*
7201
+ * Copyright 2011 Mozilla Foundation and contributors
7202
+ * Licensed under the New BSD license. See LICENSE or:
7203
+ * http://opensource.org/licenses/BSD-3-Clause
7204
+ */
7205
+ if (typeof define !== 'function') {
7206
+ var define = require('amdefine')(module, require);
7207
+ }
7208
+ define(function (require, exports, module) {
7209
+
7210
+ var base64VLQ = require('./base64-vlq');
7211
+ var util = require('./util');
7212
+ var ArraySet = require('./array-set').ArraySet;
7213
+
7214
+ /**
7215
+ * An instance of the SourceMapGenerator represents a source map which is
7216
+ * being built incrementally. You may pass an object with the following
7217
+ * properties:
7218
+ *
7219
+ * - file: The filename of the generated source.
7220
+ * - sourceRoot: A root for all relative URLs in this source map.
7221
+ */
7222
+ function SourceMapGenerator(aArgs) {
7223
+ if (!aArgs) {
7224
+ aArgs = {};
7225
+ }
7226
+ this._file = util.getArg(aArgs, 'file', null);
7227
+ this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
7228
+ this._sources = new ArraySet();
7229
+ this._names = new ArraySet();
7230
+ this._mappings = [];
7231
+ this._sourcesContents = null;
7232
+ }
7233
+
7234
+ SourceMapGenerator.prototype._version = 3;
7235
+
7236
+ /**
7237
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
7238
+ *
7239
+ * @param aSourceMapConsumer The SourceMap.
7240
+ */
7241
+ SourceMapGenerator.fromSourceMap =
7242
+ function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
7243
+ var sourceRoot = aSourceMapConsumer.sourceRoot;
7244
+ var generator = new SourceMapGenerator({
7245
+ file: aSourceMapConsumer.file,
7246
+ sourceRoot: sourceRoot
7247
+ });
7248
+ aSourceMapConsumer.eachMapping(function (mapping) {
7249
+ var newMapping = {
7250
+ generated: {
7251
+ line: mapping.generatedLine,
7252
+ column: mapping.generatedColumn
7253
+ }
7254
+ };
7255
+
7256
+ if (mapping.source != null) {
7257
+ newMapping.source = mapping.source;
7258
+ if (sourceRoot != null) {
7259
+ newMapping.source = util.relative(sourceRoot, newMapping.source);
7260
+ }
7261
+
7262
+ newMapping.original = {
7263
+ line: mapping.originalLine,
7264
+ column: mapping.originalColumn
7265
+ };
7266
+
7267
+ if (mapping.name != null) {
7268
+ newMapping.name = mapping.name;
7269
+ }
7270
+ }
7271
+
7272
+ generator.addMapping(newMapping);
7273
+ });
7274
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
7275
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
7276
+ if (content != null) {
7277
+ generator.setSourceContent(sourceFile, content);
7278
+ }
7279
+ });
7280
+ return generator;
7281
+ };
7282
+
7283
+ /**
7284
+ * Add a single mapping from original source line and column to the generated
7285
+ * source's line and column for this source map being created. The mapping
7286
+ * object should have the following properties:
7287
+ *
7288
+ * - generated: An object with the generated line and column positions.
7289
+ * - original: An object with the original line and column positions.
7290
+ * - source: The original source file (relative to the sourceRoot).
7291
+ * - name: An optional original token name for this mapping.
7292
+ */
7293
+ SourceMapGenerator.prototype.addMapping =
7294
+ function SourceMapGenerator_addMapping(aArgs) {
7295
+ var generated = util.getArg(aArgs, 'generated');
7296
+ var original = util.getArg(aArgs, 'original', null);
7297
+ var source = util.getArg(aArgs, 'source', null);
7298
+ var name = util.getArg(aArgs, 'name', null);
7299
+
7300
+ this._validateMapping(generated, original, source, name);
7301
+
7302
+ if (source != null && !this._sources.has(source)) {
7303
+ this._sources.add(source);
7304
+ }
7305
+
7306
+ if (name != null && !this._names.has(name)) {
7307
+ this._names.add(name);
7308
+ }
7309
+
7310
+ this._mappings.push({
7311
+ generatedLine: generated.line,
7312
+ generatedColumn: generated.column,
7313
+ originalLine: original != null && original.line,
7314
+ originalColumn: original != null && original.column,
7315
+ source: source,
7316
+ name: name
7317
+ });
7318
+ };
7319
+
7320
+ /**
7321
+ * Set the source content for a source file.
7322
+ */
7323
+ SourceMapGenerator.prototype.setSourceContent =
7324
+ function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
7325
+ var source = aSourceFile;
7326
+ if (this._sourceRoot != null) {
7327
+ source = util.relative(this._sourceRoot, source);
7328
+ }
7329
+
7330
+ if (aSourceContent != null) {
7331
+ // Add the source content to the _sourcesContents map.
7332
+ // Create a new _sourcesContents map if the property is null.
7333
+ if (!this._sourcesContents) {
7334
+ this._sourcesContents = {};
7335
+ }
7336
+ this._sourcesContents[util.toSetString(source)] = aSourceContent;
7337
+ } else {
7338
+ // Remove the source file from the _sourcesContents map.
7339
+ // If the _sourcesContents map is empty, set the property to null.
7340
+ delete this._sourcesContents[util.toSetString(source)];
7341
+ if (Object.keys(this._sourcesContents).length === 0) {
7342
+ this._sourcesContents = null;
7343
+ }
7344
+ }
7345
+ };
7346
+
7347
+ /**
7348
+ * Applies the mappings of a sub-source-map for a specific source file to the
7349
+ * source map being generated. Each mapping to the supplied source file is
7350
+ * rewritten using the supplied source map. Note: The resolution for the
7351
+ * resulting mappings is the minimium of this map and the supplied map.
7352
+ *
7353
+ * @param aSourceMapConsumer The source map to be applied.
7354
+ * @param aSourceFile Optional. The filename of the source file.
7355
+ * If omitted, SourceMapConsumer's file property will be used.
7356
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
7357
+ * to be applied. If relative, it is relative to the SourceMapConsumer.
7358
+ * This parameter is needed when the two source maps aren't in the same
7359
+ * directory, and the source map to be applied contains relative source
7360
+ * paths. If so, those relative source paths need to be rewritten
7361
+ * relative to the SourceMapGenerator.
7362
+ */
7363
+ SourceMapGenerator.prototype.applySourceMap =
7364
+ function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
7365
+ var sourceFile = aSourceFile;
7366
+ // If aSourceFile is omitted, we will use the file property of the SourceMap
7367
+ if (aSourceFile == null) {
7368
+ if (aSourceMapConsumer.file == null) {
7369
+ throw new Error(
7370
+ 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
7371
+ 'or the source map\'s "file" property. Both were omitted.'
7372
+ );
7373
+ }
7374
+ sourceFile = aSourceMapConsumer.file;
7375
+ }
7376
+ var sourceRoot = this._sourceRoot;
7377
+ // Make "sourceFile" relative if an absolute Url is passed.
7378
+ if (sourceRoot != null) {
7379
+ sourceFile = util.relative(sourceRoot, sourceFile);
7380
+ }
7381
+ // Applying the SourceMap can add and remove items from the sources and
7382
+ // the names array.
7383
+ var newSources = new ArraySet();
7384
+ var newNames = new ArraySet();
7385
+
7386
+ // Find mappings for the "sourceFile"
7387
+ this._mappings.forEach(function (mapping) {
7388
+ if (mapping.source === sourceFile && mapping.originalLine != null) {
7389
+ // Check if it can be mapped by the source map, then update the mapping.
7390
+ var original = aSourceMapConsumer.originalPositionFor({
7391
+ line: mapping.originalLine,
7392
+ column: mapping.originalColumn
7393
+ });
7394
+ if (original.source != null) {
7395
+ // Copy mapping
7396
+ mapping.source = original.source;
7397
+ if (aSourceMapPath != null) {
7398
+ mapping.source = util.join(aSourceMapPath, mapping.source)
7399
+ }
7400
+ if (sourceRoot != null) {
7401
+ mapping.source = util.relative(sourceRoot, mapping.source);
7402
+ }
7403
+ mapping.originalLine = original.line;
7404
+ mapping.originalColumn = original.column;
7405
+ if (original.name != null && mapping.name != null) {
7406
+ // Only use the identifier name if it's an identifier
7407
+ // in both SourceMaps
7408
+ mapping.name = original.name;
7409
+ }
7410
+ }
7411
+ }
7412
+
7413
+ var source = mapping.source;
7414
+ if (source != null && !newSources.has(source)) {
7415
+ newSources.add(source);
7416
+ }
7417
+
7418
+ var name = mapping.name;
7419
+ if (name != null && !newNames.has(name)) {
7420
+ newNames.add(name);
7421
+ }
7422
+
7423
+ }, this);
7424
+ this._sources = newSources;
7425
+ this._names = newNames;
7426
+
7427
+ // Copy sourcesContents of applied map.
7428
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
7429
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
7430
+ if (content != null) {
7431
+ if (aSourceMapPath != null) {
7432
+ sourceFile = util.join(aSourceMapPath, sourceFile);
7433
+ }
7434
+ if (sourceRoot != null) {
7435
+ sourceFile = util.relative(sourceRoot, sourceFile);
7436
+ }
7437
+ this.setSourceContent(sourceFile, content);
7438
+ }
7439
+ }, this);
7440
+ };
7441
+
7442
+ /**
7443
+ * A mapping can have one of the three levels of data:
7444
+ *
7445
+ * 1. Just the generated position.
7446
+ * 2. The Generated position, original position, and original source.
7447
+ * 3. Generated and original position, original source, as well as a name
7448
+ * token.
7449
+ *
7450
+ * To maintain consistency, we validate that any new mapping being added falls
7451
+ * in to one of these categories.
7452
+ */
7453
+ SourceMapGenerator.prototype._validateMapping =
7454
+ function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
7455
+ aName) {
7456
+ if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
7457
+ && aGenerated.line > 0 && aGenerated.column >= 0
7458
+ && !aOriginal && !aSource && !aName) {
7459
+ // Case 1.
7460
+ return;
7461
+ }
7462
+ else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
7463
+ && aOriginal && 'line' in aOriginal && 'column' in aOriginal
7464
+ && aGenerated.line > 0 && aGenerated.column >= 0
7465
+ && aOriginal.line > 0 && aOriginal.column >= 0
7466
+ && aSource) {
7467
+ // Cases 2 and 3.
7468
+ return;
7469
+ }
7470
+ else {
7471
+ throw new Error('Invalid mapping: ' + JSON.stringify({
7472
+ generated: aGenerated,
7473
+ source: aSource,
7474
+ original: aOriginal,
7475
+ name: aName
7476
+ }));
7477
+ }
7478
+ };
7479
+
7480
+ /**
7481
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
7482
+ * specified by the source map format.
7483
+ */
7484
+ SourceMapGenerator.prototype._serializeMappings =
7485
+ function SourceMapGenerator_serializeMappings() {
7486
+ var previousGeneratedColumn = 0;
7487
+ var previousGeneratedLine = 1;
7488
+ var previousOriginalColumn = 0;
7489
+ var previousOriginalLine = 0;
7490
+ var previousName = 0;
7491
+ var previousSource = 0;
7492
+ var result = '';
7493
+ var mapping;
7494
+
7495
+ // The mappings must be guaranteed to be in sorted order before we start
7496
+ // serializing them or else the generated line numbers (which are defined
7497
+ // via the ';' separators) will be all messed up. Note: it might be more
7498
+ // performant to maintain the sorting as we insert them, rather than as we
7499
+ // serialize them, but the big O is the same either way.
7500
+ this._mappings.sort(util.compareByGeneratedPositions);
7501
+
7502
+ for (var i = 0, len = this._mappings.length; i < len; i++) {
7503
+ mapping = this._mappings[i];
7504
+
7505
+ if (mapping.generatedLine !== previousGeneratedLine) {
7506
+ previousGeneratedColumn = 0;
7507
+ while (mapping.generatedLine !== previousGeneratedLine) {
7508
+ result += ';';
7509
+ previousGeneratedLine++;
7510
+ }
7511
+ }
7512
+ else {
7513
+ if (i > 0) {
7514
+ if (!util.compareByGeneratedPositions(mapping, this._mappings[i - 1])) {
7515
+ continue;
7516
+ }
7517
+ result += ',';
7518
+ }
7519
+ }
7520
+
7521
+ result += base64VLQ.encode(mapping.generatedColumn
7522
+ - previousGeneratedColumn);
7523
+ previousGeneratedColumn = mapping.generatedColumn;
7524
+
7525
+ if (mapping.source != null) {
7526
+ result += base64VLQ.encode(this._sources.indexOf(mapping.source)
7527
+ - previousSource);
7528
+ previousSource = this._sources.indexOf(mapping.source);
7529
+
7530
+ // lines are stored 0-based in SourceMap spec version 3
7531
+ result += base64VLQ.encode(mapping.originalLine - 1
7532
+ - previousOriginalLine);
7533
+ previousOriginalLine = mapping.originalLine - 1;
7534
+
7535
+ result += base64VLQ.encode(mapping.originalColumn
7536
+ - previousOriginalColumn);
7537
+ previousOriginalColumn = mapping.originalColumn;
7538
+
7539
+ if (mapping.name != null) {
7540
+ result += base64VLQ.encode(this._names.indexOf(mapping.name)
7541
+ - previousName);
7542
+ previousName = this._names.indexOf(mapping.name);
7543
+ }
7544
+ }
7545
+ }
7546
+
7547
+ return result;
7548
+ };
7549
+
7550
+ SourceMapGenerator.prototype._generateSourcesContent =
7551
+ function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
7552
+ return aSources.map(function (source) {
7553
+ if (!this._sourcesContents) {
7554
+ return null;
7555
+ }
7556
+ if (aSourceRoot != null) {
7557
+ source = util.relative(aSourceRoot, source);
7558
+ }
7559
+ var key = util.toSetString(source);
7560
+ return Object.prototype.hasOwnProperty.call(this._sourcesContents,
7561
+ key)
7562
+ ? this._sourcesContents[key]
7563
+ : null;
7564
+ }, this);
7565
+ };
7566
+
7567
+ /**
7568
+ * Externalize the source map.
7569
+ */
7570
+ SourceMapGenerator.prototype.toJSON =
7571
+ function SourceMapGenerator_toJSON() {
7572
+ var map = {
7573
+ version: this._version,
7574
+ sources: this._sources.toArray(),
7575
+ names: this._names.toArray(),
7576
+ mappings: this._serializeMappings()
7577
+ };
7578
+ if (this._file != null) {
7579
+ map.file = this._file;
7580
+ }
7581
+ if (this._sourceRoot != null) {
7582
+ map.sourceRoot = this._sourceRoot;
7583
+ }
7584
+ if (this._sourcesContents) {
7585
+ map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
7586
+ }
7587
+
7588
+ return map;
7589
+ };
7590
+
7591
+ /**
7592
+ * Render the source map being generated to a string.
7593
+ */
7594
+ SourceMapGenerator.prototype.toString =
7595
+ function SourceMapGenerator_toString() {
7596
+ return JSON.stringify(this);
7597
+ };
7598
+
7599
+ exports.SourceMapGenerator = SourceMapGenerator;
7600
+
7601
+ });
7602
+
7603
+ },{"./array-set":20,"./base64-vlq":21,"./util":27,"amdefine":28}],26:[function(require,module,exports){
7604
+ /* -*- Mode: js; js-indent-level: 2; -*- */
7605
+ /*
7606
+ * Copyright 2011 Mozilla Foundation and contributors
7607
+ * Licensed under the New BSD license. See LICENSE or:
7608
+ * http://opensource.org/licenses/BSD-3-Clause
7609
+ */
7610
+ if (typeof define !== 'function') {
7611
+ var define = require('amdefine')(module, require);
7612
+ }
7613
+ define(function (require, exports, module) {
7614
+
7615
+ var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
7616
+ var util = require('./util');
7617
+
7618
+ // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
7619
+ // operating systems these days (capturing the result).
7620
+ var REGEX_NEWLINE = /(\r?\n)/;
7621
+
7622
+ // Matches a Windows-style newline, or any character.
7623
+ var REGEX_CHARACTER = /\r\n|[\s\S]/g;
7624
+
7625
+ /**
7626
+ * SourceNodes provide a way to abstract over interpolating/concatenating
7627
+ * snippets of generated JavaScript source code while maintaining the line and
7628
+ * column information associated with the original source code.
7629
+ *
7630
+ * @param aLine The original line number.
7631
+ * @param aColumn The original column number.
7632
+ * @param aSource The original source's filename.
7633
+ * @param aChunks Optional. An array of strings which are snippets of
7634
+ * generated JS, or other SourceNodes.
7635
+ * @param aName The original identifier.
7636
+ */
7637
+ function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
7638
+ this.children = [];
7639
+ this.sourceContents = {};
7640
+ this.line = aLine == null ? null : aLine;
7641
+ this.column = aColumn == null ? null : aColumn;
7642
+ this.source = aSource == null ? null : aSource;
7643
+ this.name = aName == null ? null : aName;
7644
+ if (aChunks != null) this.add(aChunks);
7645
+ }
7646
+
7647
+ /**
7648
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
7649
+ *
7650
+ * @param aGeneratedCode The generated code
7651
+ * @param aSourceMapConsumer The SourceMap for the generated code
7652
+ * @param aRelativePath Optional. The path that relative sources in the
7653
+ * SourceMapConsumer should be relative to.
7654
+ */
7655
+ SourceNode.fromStringWithSourceMap =
7656
+ function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
7657
+ // The SourceNode we want to fill with the generated code
7658
+ // and the SourceMap
7659
+ var node = new SourceNode();
7660
+
7661
+ // All even indices of this array are one line of the generated code,
7662
+ // while all odd indices are the newlines between two adjacent lines
7663
+ // (since `REGEX_NEWLINE` captures its match).
7664
+ // Processed fragments are removed from this array, by calling `shiftNextLine`.
7665
+ var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
7666
+ var shiftNextLine = function() {
7667
+ var lineContents = remainingLines.shift();
7668
+ // The last line of a file might not have a newline.
7669
+ var newLine = remainingLines.shift() || "";
7670
+ return lineContents + newLine;
7671
+ };
7672
+
7673
+ // We need to remember the position of "remainingLines"
7674
+ var lastGeneratedLine = 1, lastGeneratedColumn = 0;
7675
+
7676
+ // The generate SourceNodes we need a code range.
7677
+ // To extract it current and last mapping is used.
7678
+ // Here we store the last mapping.
7679
+ var lastMapping = null;
7680
+
7681
+ aSourceMapConsumer.eachMapping(function (mapping) {
7682
+ if (lastMapping !== null) {
7683
+ // We add the code from "lastMapping" to "mapping":
7684
+ // First check if there is a new line in between.
7685
+ if (lastGeneratedLine < mapping.generatedLine) {
7686
+ var code = "";
7687
+ // Associate first line with "lastMapping"
7688
+ addMappingWithCode(lastMapping, shiftNextLine());
7689
+ lastGeneratedLine++;
7690
+ lastGeneratedColumn = 0;
7691
+ // The remaining code is added without mapping
7692
+ } else {
7693
+ // There is no new line in between.
7694
+ // Associate the code between "lastGeneratedColumn" and
7695
+ // "mapping.generatedColumn" with "lastMapping"
7696
+ var nextLine = remainingLines[0];
7697
+ var code = nextLine.substr(0, mapping.generatedColumn -
7698
+ lastGeneratedColumn);
7699
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn -
7700
+ lastGeneratedColumn);
7701
+ lastGeneratedColumn = mapping.generatedColumn;
7702
+ addMappingWithCode(lastMapping, code);
7703
+ // No more remaining code, continue
7704
+ lastMapping = mapping;
7705
+ return;
7706
+ }
7707
+ }
7708
+ // We add the generated code until the first mapping
7709
+ // to the SourceNode without any mapping.
7710
+ // Each line is added as separate string.
7711
+ while (lastGeneratedLine < mapping.generatedLine) {
7712
+ node.add(shiftNextLine());
7713
+ lastGeneratedLine++;
7714
+ }
7715
+ if (lastGeneratedColumn < mapping.generatedColumn) {
7716
+ var nextLine = remainingLines[0];
7717
+ node.add(nextLine.substr(0, mapping.generatedColumn));
7718
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn);
7719
+ lastGeneratedColumn = mapping.generatedColumn;
7720
+ }
7721
+ lastMapping = mapping;
7722
+ }, this);
7723
+ // We have processed all mappings.
7724
+ if (remainingLines.length > 0) {
7725
+ if (lastMapping) {
7726
+ // Associate the remaining code in the current line with "lastMapping"
7727
+ addMappingWithCode(lastMapping, shiftNextLine());
7728
+ }
7729
+ // and add the remaining lines without any mapping
7730
+ node.add(remainingLines.join(""));
7731
+ }
7732
+
7733
+ // Copy sourcesContent into SourceNode
7734
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
7735
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
7736
+ if (content != null) {
7737
+ if (aRelativePath != null) {
7738
+ sourceFile = util.join(aRelativePath, sourceFile);
7739
+ }
7740
+ node.setSourceContent(sourceFile, content);
7741
+ }
7742
+ });
7743
+
7744
+ return node;
7745
+
7746
+ function addMappingWithCode(mapping, code) {
7747
+ if (mapping === null || mapping.source === undefined) {
7748
+ node.add(code);
7749
+ } else {
7750
+ var source = aRelativePath
7751
+ ? util.join(aRelativePath, mapping.source)
7752
+ : mapping.source;
7753
+ node.add(new SourceNode(mapping.originalLine,
7754
+ mapping.originalColumn,
7755
+ source,
7756
+ code,
7757
+ mapping.name));
7758
+ }
7759
+ }
7760
+ };
7761
+
7762
+ /**
7763
+ * Add a chunk of generated JS to this source node.
7764
+ *
7765
+ * @param aChunk A string snippet of generated JS code, another instance of
7766
+ * SourceNode, or an array where each member is one of those things.
7767
+ */
7768
+ SourceNode.prototype.add = function SourceNode_add(aChunk) {
7769
+ if (Array.isArray(aChunk)) {
7770
+ aChunk.forEach(function (chunk) {
7771
+ this.add(chunk);
7772
+ }, this);
7773
+ }
7774
+ else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
7775
+ if (aChunk) {
7776
+ this.children.push(aChunk);
7777
+ }
7778
+ }
7779
+ else {
7780
+ throw new TypeError(
7781
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
7782
+ );
7783
+ }
7784
+ return this;
7785
+ };
7786
+
7787
+ /**
7788
+ * Add a chunk of generated JS to the beginning of this source node.
7789
+ *
7790
+ * @param aChunk A string snippet of generated JS code, another instance of
7791
+ * SourceNode, or an array where each member is one of those things.
7792
+ */
7793
+ SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
7794
+ if (Array.isArray(aChunk)) {
7795
+ for (var i = aChunk.length-1; i >= 0; i--) {
7796
+ this.prepend(aChunk[i]);
7797
+ }
7798
+ }
7799
+ else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
7800
+ this.children.unshift(aChunk);
7801
+ }
7802
+ else {
7803
+ throw new TypeError(
7804
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
7805
+ );
7806
+ }
7807
+ return this;
7808
+ };
7809
+
7810
+ /**
7811
+ * Walk over the tree of JS snippets in this node and its children. The
7812
+ * walking function is called once for each snippet of JS and is passed that
7813
+ * snippet and the its original associated source's line/column location.
7814
+ *
7815
+ * @param aFn The traversal function.
7816
+ */
7817
+ SourceNode.prototype.walk = function SourceNode_walk(aFn) {
7818
+ var chunk;
7819
+ for (var i = 0, len = this.children.length; i < len; i++) {
7820
+ chunk = this.children[i];
7821
+ if (chunk instanceof SourceNode) {
7822
+ chunk.walk(aFn);
7823
+ }
7824
+ else {
7825
+ if (chunk !== '') {
7826
+ aFn(chunk, { source: this.source,
7827
+ line: this.line,
7828
+ column: this.column,
7829
+ name: this.name });
7830
+ }
7831
+ }
7832
+ }
7833
+ };
7834
+
7835
+ /**
7836
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
7837
+ * each of `this.children`.
7838
+ *
7839
+ * @param aSep The separator.
7840
+ */
7841
+ SourceNode.prototype.join = function SourceNode_join(aSep) {
7842
+ var newChildren;
7843
+ var i;
7844
+ var len = this.children.length;
7845
+ if (len > 0) {
7846
+ newChildren = [];
7847
+ for (i = 0; i < len-1; i++) {
7848
+ newChildren.push(this.children[i]);
7849
+ newChildren.push(aSep);
7850
+ }
7851
+ newChildren.push(this.children[i]);
7852
+ this.children = newChildren;
7853
+ }
7854
+ return this;
7855
+ };
7856
+
7857
+ /**
7858
+ * Call String.prototype.replace on the very right-most source snippet. Useful
7859
+ * for trimming whitespace from the end of a source node, etc.
7860
+ *
7861
+ * @param aPattern The pattern to replace.
7862
+ * @param aReplacement The thing to replace the pattern with.
7863
+ */
7864
+ SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
7865
+ var lastChild = this.children[this.children.length - 1];
7866
+ if (lastChild instanceof SourceNode) {
7867
+ lastChild.replaceRight(aPattern, aReplacement);
7868
+ }
7869
+ else if (typeof lastChild === 'string') {
7870
+ this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
7871
+ }
7872
+ else {
7873
+ this.children.push(''.replace(aPattern, aReplacement));
7874
+ }
7875
+ return this;
7876
+ };
7877
+
7878
+ /**
7879
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
7880
+ * in the sourcesContent field.
7881
+ *
7882
+ * @param aSourceFile The filename of the source file
7883
+ * @param aSourceContent The content of the source file
7884
+ */
7885
+ SourceNode.prototype.setSourceContent =
7886
+ function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
7887
+ this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
7888
+ };
7889
+
7890
+ /**
7891
+ * Walk over the tree of SourceNodes. The walking function is called for each
7892
+ * source file content and is passed the filename and source content.
7893
+ *
7894
+ * @param aFn The traversal function.
7895
+ */
7896
+ SourceNode.prototype.walkSourceContents =
7897
+ function SourceNode_walkSourceContents(aFn) {
7898
+ for (var i = 0, len = this.children.length; i < len; i++) {
7899
+ if (this.children[i] instanceof SourceNode) {
7900
+ this.children[i].walkSourceContents(aFn);
7901
+ }
7902
+ }
7903
+
7904
+ var sources = Object.keys(this.sourceContents);
7905
+ for (var i = 0, len = sources.length; i < len; i++) {
7906
+ aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
7907
+ }
7908
+ };
7909
+
7910
+ /**
7911
+ * Return the string representation of this source node. Walks over the tree
7912
+ * and concatenates all the various snippets together to one string.
7913
+ */
7914
+ SourceNode.prototype.toString = function SourceNode_toString() {
7915
+ var str = "";
7916
+ this.walk(function (chunk) {
7917
+ str += chunk;
7918
+ });
7919
+ return str;
7920
+ };
7921
+
7922
+ /**
7923
+ * Returns the string representation of this source node along with a source
7924
+ * map.
7925
+ */
7926
+ SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
7927
+ var generated = {
7928
+ code: "",
7929
+ line: 1,
7930
+