ngannotate-rails 0.9.7 → 0.9.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +8 -8
- data/lib/ngannotate/rails/version.rb +1 -1
- data/vendor/ngannotate.js +2885 -183
- metadata +2 -2
checksums.yaml
CHANGED
@@ -1,15 +1,15 @@
|
|
1
1
|
---
|
2
2
|
!binary "U0hBMQ==":
|
3
3
|
metadata.gz: !binary |-
|
4
|
-
|
4
|
+
ODQ2NmUwNTEwZDE5MTA2YzUwZTg2ZGM0NWVlMjM2NzcxYzdhMWM3YQ==
|
5
5
|
data.tar.gz: !binary |-
|
6
|
-
|
6
|
+
MWNhYWZlMTQ3NzZmYmEzYmYzNzIzNmNjZmI0OThlMGVjYzg5YmJkMw==
|
7
7
|
SHA512:
|
8
8
|
metadata.gz: !binary |-
|
9
|
-
|
10
|
-
|
11
|
-
|
9
|
+
YmE0MDM1MGYyNjI2NzEzMzlmNWZiYWE1NGMxNDRiZTk1MzYzMTA4ODYyNzRh
|
10
|
+
M2VmODNiMzhiOGFhNWVlNTY2MzAyNjY4MjM1OTZmOGFjN2VhMmI1NmFiYzk3
|
11
|
+
NGQxNzlhZDg1M2ZhMzhkODE4YTUxMmRmOGRhNWYxYTA5NzhkN2M=
|
12
12
|
data.tar.gz: !binary |-
|
13
|
-
|
14
|
-
|
15
|
-
|
13
|
+
MTkzNDQxZjc3OWFlMmE1MTdkYjcwYjU5OGE3OTAwNmQ5YWQ2ZmY3ZDMzNTZl
|
14
|
+
MGZiNzlkMzMyNTYwYWNiNjMzMzA4ZWVjZWM5Njc3YTU2NjcyZWJlNmViNWRh
|
15
|
+
MWI4Mzc1ODk4MzQwODExM2NiMjRmODM3ZjY1NjZlMTNkMThkNTM=
|
data/vendor/ngannotate.js
CHANGED
@@ -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);
|
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(
|
960
|
-
},{"./support/isBuffer":2,"
|
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
|
-
},{}],
|
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":
|
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":
|
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
|
-
|
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("
|
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":
|
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":
|
1771
|
-
|
1772
|
-
|
1773
|
-
|
1774
|
-
(
|
1775
|
-
|
1776
|
-
|
1777
|
-
|
1778
|
-
|
1779
|
-
|
1780
|
-
|
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
|
-
|
1784
|
-
|
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
|
-
|
1787
|
-
|
1788
|
-
|
1789
|
-
|
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
|
-
|
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
|
-
|
1796
|
-
|
1797
|
-
|
1798
|
-
|
1799
|
-
|
1800
|
-
|
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
|
-
|
1805
|
-
|
1806
|
-
if (len <= 1) {
|
1807
|
-
return arr;
|
1808
|
-
}
|
2216
|
+
(function (root, factory) {
|
2217
|
+
'use strict';
|
1809
2218
|
|
1810
|
-
//
|
1811
|
-
//
|
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
|
-
|
1818
|
-
|
1819
|
-
|
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
|
-
|
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
|
-
},{}],
|
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
|
-
},{}],
|
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":
|
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
|
-
},{}],
|
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
|
-
},{}],
|
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
|
-
},{}]
|
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
|
+
column: 0
|
7931
|
+
};
|
7932
|
+
var map = new SourceMapGenerator(aArgs);
|
7933
|
+
var sourceMappingActive = false;
|
7934
|
+
var lastOriginalSource = null;
|
7935
|
+
var lastOriginalLine = null;
|
7936
|
+
var lastOriginalColumn = null;
|
7937
|
+
var lastOriginalName = null;
|
7938
|
+
this.walk(function (chunk, original) {
|
7939
|
+
generated.code += chunk;
|
7940
|
+
if (original.source !== null
|
7941
|
+
&& original.line !== null
|
7942
|
+
&& original.column !== null) {
|
7943
|
+
if(lastOriginalSource !== original.source
|
7944
|
+
|| lastOriginalLine !== original.line
|
7945
|
+
|| lastOriginalColumn !== original.column
|
7946
|
+
|| lastOriginalName !== original.name) {
|
7947
|
+
map.addMapping({
|
7948
|
+
source: original.source,
|
7949
|
+
original: {
|
7950
|
+
line: original.line,
|
7951
|
+
column: original.column
|
7952
|
+
},
|
7953
|
+
generated: {
|
7954
|
+
line: generated.line,
|
7955
|
+
column: generated.column
|
7956
|
+
},
|
7957
|
+
name: original.name
|
7958
|
+
});
|
7959
|
+
}
|
7960
|
+
lastOriginalSource = original.source;
|
7961
|
+
lastOriginalLine = original.line;
|
7962
|
+
lastOriginalColumn = original.column;
|
7963
|
+
lastOriginalName = original.name;
|
7964
|
+
sourceMappingActive = true;
|
7965
|
+
} else if (sourceMappingActive) {
|
7966
|
+
map.addMapping({
|
7967
|
+
generated: {
|
7968
|
+
line: generated.line,
|
7969
|
+
column: generated.column
|
7970
|
+
}
|
7971
|
+
});
|
7972
|
+
lastOriginalSource = null;
|
7973
|
+
sourceMappingActive = false;
|
7974
|
+
}
|
7975
|
+
chunk.match(REGEX_CHARACTER).forEach(function (ch, idx, array) {
|
7976
|
+
if (REGEX_NEWLINE.test(ch)) {
|
7977
|
+
generated.line++;
|
7978
|
+
generated.column = 0;
|
7979
|
+
// Mappings end at eol
|
7980
|
+
if (idx + 1 === array.length) {
|
7981
|
+
lastOriginalSource = null;
|
7982
|
+
sourceMappingActive = false;
|
7983
|
+
} else if (sourceMappingActive) {
|
7984
|
+
map.addMapping({
|
7985
|
+
source: original.source,
|
7986
|
+
original: {
|
7987
|
+
line: original.line,
|
7988
|
+
column: original.column
|
7989
|
+
},
|
7990
|
+
generated: {
|
7991
|
+
line: generated.line,
|
7992
|
+
column: generated.column
|
7993
|
+
},
|
7994
|
+
name: original.name
|
7995
|
+
});
|
7996
|
+
}
|
7997
|
+
} else {
|
7998
|
+
generated.column += ch.length;
|
7999
|
+
}
|
8000
|
+
});
|
8001
|
+
});
|
8002
|
+
this.walkSourceContents(function (sourceFile, sourceContent) {
|
8003
|
+
map.setSourceContent(sourceFile, sourceContent);
|
8004
|
+
});
|
8005
|
+
|
8006
|
+
return { code: generated.code, map: map };
|
8007
|
+
};
|
8008
|
+
|
8009
|
+
exports.SourceNode = SourceNode;
|
8010
|
+
|
8011
|
+
});
|
8012
|
+
|
8013
|
+
},{"./source-map-generator":25,"./util":27,"amdefine":28}],27:[function(require,module,exports){
|
8014
|
+
/* -*- Mode: js; js-indent-level: 2; -*- */
|
8015
|
+
/*
|
8016
|
+
* Copyright 2011 Mozilla Foundation and contributors
|
8017
|
+
* Licensed under the New BSD license. See LICENSE or:
|
8018
|
+
* http://opensource.org/licenses/BSD-3-Clause
|
8019
|
+
*/
|
8020
|
+
if (typeof define !== 'function') {
|
8021
|
+
var define = require('amdefine')(module, require);
|
8022
|
+
}
|
8023
|
+
define(function (require, exports, module) {
|
8024
|
+
|
8025
|
+
/**
|
8026
|
+
* This is a helper function for getting values from parameter/options
|
8027
|
+
* objects.
|
8028
|
+
*
|
8029
|
+
* @param args The object we are extracting values from
|
8030
|
+
* @param name The name of the property we are getting.
|
8031
|
+
* @param defaultValue An optional value to return if the property is missing
|
8032
|
+
* from the object. If this is not specified and the property is missing, an
|
8033
|
+
* error will be thrown.
|
8034
|
+
*/
|
8035
|
+
function getArg(aArgs, aName, aDefaultValue) {
|
8036
|
+
if (aName in aArgs) {
|
8037
|
+
return aArgs[aName];
|
8038
|
+
} else if (arguments.length === 3) {
|
8039
|
+
return aDefaultValue;
|
8040
|
+
} else {
|
8041
|
+
throw new Error('"' + aName + '" is a required argument.');
|
8042
|
+
}
|
8043
|
+
}
|
8044
|
+
exports.getArg = getArg;
|
8045
|
+
|
8046
|
+
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
|
8047
|
+
var dataUrlRegexp = /^data:.+\,.+$/;
|
8048
|
+
|
8049
|
+
function urlParse(aUrl) {
|
8050
|
+
var match = aUrl.match(urlRegexp);
|
8051
|
+
if (!match) {
|
8052
|
+
return null;
|
8053
|
+
}
|
8054
|
+
return {
|
8055
|
+
scheme: match[1],
|
8056
|
+
auth: match[2],
|
8057
|
+
host: match[3],
|
8058
|
+
port: match[4],
|
8059
|
+
path: match[5]
|
8060
|
+
};
|
8061
|
+
}
|
8062
|
+
exports.urlParse = urlParse;
|
8063
|
+
|
8064
|
+
function urlGenerate(aParsedUrl) {
|
8065
|
+
var url = '';
|
8066
|
+
if (aParsedUrl.scheme) {
|
8067
|
+
url += aParsedUrl.scheme + ':';
|
8068
|
+
}
|
8069
|
+
url += '//';
|
8070
|
+
if (aParsedUrl.auth) {
|
8071
|
+
url += aParsedUrl.auth + '@';
|
8072
|
+
}
|
8073
|
+
if (aParsedUrl.host) {
|
8074
|
+
url += aParsedUrl.host;
|
8075
|
+
}
|
8076
|
+
if (aParsedUrl.port) {
|
8077
|
+
url += ":" + aParsedUrl.port
|
8078
|
+
}
|
8079
|
+
if (aParsedUrl.path) {
|
8080
|
+
url += aParsedUrl.path;
|
8081
|
+
}
|
8082
|
+
return url;
|
8083
|
+
}
|
8084
|
+
exports.urlGenerate = urlGenerate;
|
8085
|
+
|
8086
|
+
/**
|
8087
|
+
* Normalizes a path, or the path portion of a URL:
|
8088
|
+
*
|
8089
|
+
* - Replaces consequtive slashes with one slash.
|
8090
|
+
* - Removes unnecessary '.' parts.
|
8091
|
+
* - Removes unnecessary '<dir>/..' parts.
|
8092
|
+
*
|
8093
|
+
* Based on code in the Node.js 'path' core module.
|
8094
|
+
*
|
8095
|
+
* @param aPath The path or url to normalize.
|
8096
|
+
*/
|
8097
|
+
function normalize(aPath) {
|
8098
|
+
var path = aPath;
|
8099
|
+
var url = urlParse(aPath);
|
8100
|
+
if (url) {
|
8101
|
+
if (!url.path) {
|
8102
|
+
return aPath;
|
8103
|
+
}
|
8104
|
+
path = url.path;
|
8105
|
+
}
|
8106
|
+
var isAbsolute = (path.charAt(0) === '/');
|
8107
|
+
|
8108
|
+
var parts = path.split(/\/+/);
|
8109
|
+
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
|
8110
|
+
part = parts[i];
|
8111
|
+
if (part === '.') {
|
8112
|
+
parts.splice(i, 1);
|
8113
|
+
} else if (part === '..') {
|
8114
|
+
up++;
|
8115
|
+
} else if (up > 0) {
|
8116
|
+
if (part === '') {
|
8117
|
+
// The first part is blank if the path is absolute. Trying to go
|
8118
|
+
// above the root is a no-op. Therefore we can remove all '..' parts
|
8119
|
+
// directly after the root.
|
8120
|
+
parts.splice(i + 1, up);
|
8121
|
+
up = 0;
|
8122
|
+
} else {
|
8123
|
+
parts.splice(i, 2);
|
8124
|
+
up--;
|
8125
|
+
}
|
8126
|
+
}
|
8127
|
+
}
|
8128
|
+
path = parts.join('/');
|
8129
|
+
|
8130
|
+
if (path === '') {
|
8131
|
+
path = isAbsolute ? '/' : '.';
|
8132
|
+
}
|
8133
|
+
|
8134
|
+
if (url) {
|
8135
|
+
url.path = path;
|
8136
|
+
return urlGenerate(url);
|
8137
|
+
}
|
8138
|
+
return path;
|
8139
|
+
}
|
8140
|
+
exports.normalize = normalize;
|
8141
|
+
|
8142
|
+
/**
|
8143
|
+
* Joins two paths/URLs.
|
8144
|
+
*
|
8145
|
+
* @param aRoot The root path or URL.
|
8146
|
+
* @param aPath The path or URL to be joined with the root.
|
8147
|
+
*
|
8148
|
+
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
|
8149
|
+
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
|
8150
|
+
* first.
|
8151
|
+
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
|
8152
|
+
* is updated with the result and aRoot is returned. Otherwise the result
|
8153
|
+
* is returned.
|
8154
|
+
* - If aPath is absolute, the result is aPath.
|
8155
|
+
* - Otherwise the two paths are joined with a slash.
|
8156
|
+
* - Joining for example 'http://' and 'www.example.com' is also supported.
|
8157
|
+
*/
|
8158
|
+
function join(aRoot, aPath) {
|
8159
|
+
if (aRoot === "") {
|
8160
|
+
aRoot = ".";
|
8161
|
+
}
|
8162
|
+
if (aPath === "") {
|
8163
|
+
aPath = ".";
|
8164
|
+
}
|
8165
|
+
var aPathUrl = urlParse(aPath);
|
8166
|
+
var aRootUrl = urlParse(aRoot);
|
8167
|
+
if (aRootUrl) {
|
8168
|
+
aRoot = aRootUrl.path || '/';
|
8169
|
+
}
|
8170
|
+
|
8171
|
+
// `join(foo, '//www.example.org')`
|
8172
|
+
if (aPathUrl && !aPathUrl.scheme) {
|
8173
|
+
if (aRootUrl) {
|
8174
|
+
aPathUrl.scheme = aRootUrl.scheme;
|
8175
|
+
}
|
8176
|
+
return urlGenerate(aPathUrl);
|
8177
|
+
}
|
8178
|
+
|
8179
|
+
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
8180
|
+
return aPath;
|
8181
|
+
}
|
8182
|
+
|
8183
|
+
// `join('http://', 'www.example.com')`
|
8184
|
+
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
8185
|
+
aRootUrl.host = aPath;
|
8186
|
+
return urlGenerate(aRootUrl);
|
8187
|
+
}
|
8188
|
+
|
8189
|
+
var joined = aPath.charAt(0) === '/'
|
8190
|
+
? aPath
|
8191
|
+
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
|
8192
|
+
|
8193
|
+
if (aRootUrl) {
|
8194
|
+
aRootUrl.path = joined;
|
8195
|
+
return urlGenerate(aRootUrl);
|
8196
|
+
}
|
8197
|
+
return joined;
|
8198
|
+
}
|
8199
|
+
exports.join = join;
|
8200
|
+
|
8201
|
+
/**
|
8202
|
+
* Make a path relative to a URL or another path.
|
8203
|
+
*
|
8204
|
+
* @param aRoot The root path or URL.
|
8205
|
+
* @param aPath The path or URL to be made relative to aRoot.
|
8206
|
+
*/
|
8207
|
+
function relative(aRoot, aPath) {
|
8208
|
+
if (aRoot === "") {
|
8209
|
+
aRoot = ".";
|
8210
|
+
}
|
8211
|
+
|
8212
|
+
aRoot = aRoot.replace(/\/$/, '');
|
8213
|
+
|
8214
|
+
// XXX: It is possible to remove this block, and the tests still pass!
|
8215
|
+
var url = urlParse(aRoot);
|
8216
|
+
if (aPath.charAt(0) == "/" && url && url.path == "/") {
|
8217
|
+
return aPath.slice(1);
|
8218
|
+
}
|
8219
|
+
|
8220
|
+
return aPath.indexOf(aRoot + '/') === 0
|
8221
|
+
? aPath.substr(aRoot.length + 1)
|
8222
|
+
: aPath;
|
8223
|
+
}
|
8224
|
+
exports.relative = relative;
|
8225
|
+
|
8226
|
+
/**
|
8227
|
+
* Because behavior goes wacky when you set `__proto__` on objects, we
|
8228
|
+
* have to prefix all the strings in our set with an arbitrary character.
|
8229
|
+
*
|
8230
|
+
* See https://github.com/mozilla/source-map/pull/31 and
|
8231
|
+
* https://github.com/mozilla/source-map/issues/30
|
8232
|
+
*
|
8233
|
+
* @param String aStr
|
8234
|
+
*/
|
8235
|
+
function toSetString(aStr) {
|
8236
|
+
return '$' + aStr;
|
8237
|
+
}
|
8238
|
+
exports.toSetString = toSetString;
|
8239
|
+
|
8240
|
+
function fromSetString(aStr) {
|
8241
|
+
return aStr.substr(1);
|
8242
|
+
}
|
8243
|
+
exports.fromSetString = fromSetString;
|
8244
|
+
|
8245
|
+
function strcmp(aStr1, aStr2) {
|
8246
|
+
var s1 = aStr1 || "";
|
8247
|
+
var s2 = aStr2 || "";
|
8248
|
+
return (s1 > s2) - (s1 < s2);
|
8249
|
+
}
|
8250
|
+
|
8251
|
+
/**
|
8252
|
+
* Comparator between two mappings where the original positions are compared.
|
8253
|
+
*
|
8254
|
+
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
8255
|
+
* mappings with the same original source/line/column, but different generated
|
8256
|
+
* line and column the same. Useful when searching for a mapping with a
|
8257
|
+
* stubbed out mapping.
|
8258
|
+
*/
|
8259
|
+
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
8260
|
+
var cmp;
|
8261
|
+
|
8262
|
+
cmp = strcmp(mappingA.source, mappingB.source);
|
8263
|
+
if (cmp) {
|
8264
|
+
return cmp;
|
8265
|
+
}
|
8266
|
+
|
8267
|
+
cmp = mappingA.originalLine - mappingB.originalLine;
|
8268
|
+
if (cmp) {
|
8269
|
+
return cmp;
|
8270
|
+
}
|
8271
|
+
|
8272
|
+
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
8273
|
+
if (cmp || onlyCompareOriginal) {
|
8274
|
+
return cmp;
|
8275
|
+
}
|
8276
|
+
|
8277
|
+
cmp = strcmp(mappingA.name, mappingB.name);
|
8278
|
+
if (cmp) {
|
8279
|
+
return cmp;
|
8280
|
+
}
|
8281
|
+
|
8282
|
+
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
8283
|
+
if (cmp) {
|
8284
|
+
return cmp;
|
8285
|
+
}
|
8286
|
+
|
8287
|
+
return mappingA.generatedColumn - mappingB.generatedColumn;
|
8288
|
+
};
|
8289
|
+
exports.compareByOriginalPositions = compareByOriginalPositions;
|
8290
|
+
|
8291
|
+
/**
|
8292
|
+
* Comparator between two mappings where the generated positions are
|
8293
|
+
* compared.
|
8294
|
+
*
|
8295
|
+
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
8296
|
+
* mappings with the same generated line and column, but different
|
8297
|
+
* source/name/original line and column the same. Useful when searching for a
|
8298
|
+
* mapping with a stubbed out mapping.
|
8299
|
+
*/
|
8300
|
+
function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
|
8301
|
+
var cmp;
|
8302
|
+
|
8303
|
+
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
8304
|
+
if (cmp) {
|
8305
|
+
return cmp;
|
8306
|
+
}
|
8307
|
+
|
8308
|
+
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
8309
|
+
if (cmp || onlyCompareGenerated) {
|
8310
|
+
return cmp;
|
8311
|
+
}
|
8312
|
+
|
8313
|
+
cmp = strcmp(mappingA.source, mappingB.source);
|
8314
|
+
if (cmp) {
|
8315
|
+
return cmp;
|
8316
|
+
}
|
8317
|
+
|
8318
|
+
cmp = mappingA.originalLine - mappingB.originalLine;
|
8319
|
+
if (cmp) {
|
8320
|
+
return cmp;
|
8321
|
+
}
|
8322
|
+
|
8323
|
+
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
8324
|
+
if (cmp) {
|
8325
|
+
return cmp;
|
8326
|
+
}
|
8327
|
+
|
8328
|
+
return strcmp(mappingA.name, mappingB.name);
|
8329
|
+
};
|
8330
|
+
exports.compareByGeneratedPositions = compareByGeneratedPositions;
|
8331
|
+
|
8332
|
+
});
|
8333
|
+
|
8334
|
+
},{"amdefine":28}],28:[function(require,module,exports){
|
8335
|
+
(function (process,__filename){
|
8336
|
+
/** vim: et:ts=4:sw=4:sts=4
|
8337
|
+
* @license amdefine 0.1.0 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
|
8338
|
+
* Available via the MIT or new BSD license.
|
8339
|
+
* see: http://github.com/jrburke/amdefine for details
|
8340
|
+
*/
|
8341
|
+
|
8342
|
+
/*jslint node: true */
|
8343
|
+
/*global module, process */
|
8344
|
+
'use strict';
|
8345
|
+
|
8346
|
+
/**
|
8347
|
+
* Creates a define for node.
|
8348
|
+
* @param {Object} module the "module" object that is defined by Node for the
|
8349
|
+
* current module.
|
8350
|
+
* @param {Function} [requireFn]. Node's require function for the current module.
|
8351
|
+
* It only needs to be passed in Node versions before 0.5, when module.require
|
8352
|
+
* did not exist.
|
8353
|
+
* @returns {Function} a define function that is usable for the current node
|
8354
|
+
* module.
|
8355
|
+
*/
|
8356
|
+
function amdefine(module, requireFn) {
|
8357
|
+
'use strict';
|
8358
|
+
var defineCache = {},
|
8359
|
+
loaderCache = {},
|
8360
|
+
alreadyCalled = false,
|
8361
|
+
path = require('path'),
|
8362
|
+
makeRequire, stringRequire;
|
8363
|
+
|
8364
|
+
/**
|
8365
|
+
* Trims the . and .. from an array of path segments.
|
8366
|
+
* It will keep a leading path segment if a .. will become
|
8367
|
+
* the first path segment, to help with module name lookups,
|
8368
|
+
* which act like paths, but can be remapped. But the end result,
|
8369
|
+
* all paths that use this function should look normalized.
|
8370
|
+
* NOTE: this method MODIFIES the input array.
|
8371
|
+
* @param {Array} ary the array of path segments.
|
8372
|
+
*/
|
8373
|
+
function trimDots(ary) {
|
8374
|
+
var i, part;
|
8375
|
+
for (i = 0; ary[i]; i+= 1) {
|
8376
|
+
part = ary[i];
|
8377
|
+
if (part === '.') {
|
8378
|
+
ary.splice(i, 1);
|
8379
|
+
i -= 1;
|
8380
|
+
} else if (part === '..') {
|
8381
|
+
if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
|
8382
|
+
//End of the line. Keep at least one non-dot
|
8383
|
+
//path segment at the front so it can be mapped
|
8384
|
+
//correctly to disk. Otherwise, there is likely
|
8385
|
+
//no path mapping for a path starting with '..'.
|
8386
|
+
//This can still fail, but catches the most reasonable
|
8387
|
+
//uses of ..
|
8388
|
+
break;
|
8389
|
+
} else if (i > 0) {
|
8390
|
+
ary.splice(i - 1, 2);
|
8391
|
+
i -= 2;
|
8392
|
+
}
|
8393
|
+
}
|
8394
|
+
}
|
8395
|
+
}
|
8396
|
+
|
8397
|
+
function normalize(name, baseName) {
|
8398
|
+
var baseParts;
|
8399
|
+
|
8400
|
+
//Adjust any relative paths.
|
8401
|
+
if (name && name.charAt(0) === '.') {
|
8402
|
+
//If have a base name, try to normalize against it,
|
8403
|
+
//otherwise, assume it is a top-level require that will
|
8404
|
+
//be relative to baseUrl in the end.
|
8405
|
+
if (baseName) {
|
8406
|
+
baseParts = baseName.split('/');
|
8407
|
+
baseParts = baseParts.slice(0, baseParts.length - 1);
|
8408
|
+
baseParts = baseParts.concat(name.split('/'));
|
8409
|
+
trimDots(baseParts);
|
8410
|
+
name = baseParts.join('/');
|
8411
|
+
}
|
8412
|
+
}
|
8413
|
+
|
8414
|
+
return name;
|
8415
|
+
}
|
8416
|
+
|
8417
|
+
/**
|
8418
|
+
* Create the normalize() function passed to a loader plugin's
|
8419
|
+
* normalize method.
|
8420
|
+
*/
|
8421
|
+
function makeNormalize(relName) {
|
8422
|
+
return function (name) {
|
8423
|
+
return normalize(name, relName);
|
8424
|
+
};
|
8425
|
+
}
|
8426
|
+
|
8427
|
+
function makeLoad(id) {
|
8428
|
+
function load(value) {
|
8429
|
+
loaderCache[id] = value;
|
8430
|
+
}
|
8431
|
+
|
8432
|
+
load.fromText = function (id, text) {
|
8433
|
+
//This one is difficult because the text can/probably uses
|
8434
|
+
//define, and any relative paths and requires should be relative
|
8435
|
+
//to that id was it would be found on disk. But this would require
|
8436
|
+
//bootstrapping a module/require fairly deeply from node core.
|
8437
|
+
//Not sure how best to go about that yet.
|
8438
|
+
throw new Error('amdefine does not implement load.fromText');
|
8439
|
+
};
|
8440
|
+
|
8441
|
+
return load;
|
8442
|
+
}
|
8443
|
+
|
8444
|
+
makeRequire = function (systemRequire, exports, module, relId) {
|
8445
|
+
function amdRequire(deps, callback) {
|
8446
|
+
if (typeof deps === 'string') {
|
8447
|
+
//Synchronous, single module require('')
|
8448
|
+
return stringRequire(systemRequire, exports, module, deps, relId);
|
8449
|
+
} else {
|
8450
|
+
//Array of dependencies with a callback.
|
8451
|
+
|
8452
|
+
//Convert the dependencies to modules.
|
8453
|
+
deps = deps.map(function (depName) {
|
8454
|
+
return stringRequire(systemRequire, exports, module, depName, relId);
|
8455
|
+
});
|
8456
|
+
|
8457
|
+
//Wait for next tick to call back the require call.
|
8458
|
+
process.nextTick(function () {
|
8459
|
+
callback.apply(null, deps);
|
8460
|
+
});
|
8461
|
+
}
|
8462
|
+
}
|
8463
|
+
|
8464
|
+
amdRequire.toUrl = function (filePath) {
|
8465
|
+
if (filePath.indexOf('.') === 0) {
|
8466
|
+
return normalize(filePath, path.dirname(module.filename));
|
8467
|
+
} else {
|
8468
|
+
return filePath;
|
8469
|
+
}
|
8470
|
+
};
|
8471
|
+
|
8472
|
+
return amdRequire;
|
8473
|
+
};
|
8474
|
+
|
8475
|
+
//Favor explicit value, passed in if the module wants to support Node 0.4.
|
8476
|
+
requireFn = requireFn || function req() {
|
8477
|
+
return module.require.apply(module, arguments);
|
8478
|
+
};
|
8479
|
+
|
8480
|
+
function runFactory(id, deps, factory) {
|
8481
|
+
var r, e, m, result;
|
8482
|
+
|
8483
|
+
if (id) {
|
8484
|
+
e = loaderCache[id] = {};
|
8485
|
+
m = {
|
8486
|
+
id: id,
|
8487
|
+
uri: __filename,
|
8488
|
+
exports: e
|
8489
|
+
};
|
8490
|
+
r = makeRequire(requireFn, e, m, id);
|
8491
|
+
} else {
|
8492
|
+
//Only support one define call per file
|
8493
|
+
if (alreadyCalled) {
|
8494
|
+
throw new Error('amdefine with no module ID cannot be called more than once per file.');
|
8495
|
+
}
|
8496
|
+
alreadyCalled = true;
|
8497
|
+
|
8498
|
+
//Use the real variables from node
|
8499
|
+
//Use module.exports for exports, since
|
8500
|
+
//the exports in here is amdefine exports.
|
8501
|
+
e = module.exports;
|
8502
|
+
m = module;
|
8503
|
+
r = makeRequire(requireFn, e, m, module.id);
|
8504
|
+
}
|
8505
|
+
|
8506
|
+
//If there are dependencies, they are strings, so need
|
8507
|
+
//to convert them to dependency values.
|
8508
|
+
if (deps) {
|
8509
|
+
deps = deps.map(function (depName) {
|
8510
|
+
return r(depName);
|
8511
|
+
});
|
8512
|
+
}
|
8513
|
+
|
8514
|
+
//Call the factory with the right dependencies.
|
8515
|
+
if (typeof factory === 'function') {
|
8516
|
+
result = factory.apply(m.exports, deps);
|
8517
|
+
} else {
|
8518
|
+
result = factory;
|
8519
|
+
}
|
8520
|
+
|
8521
|
+
if (result !== undefined) {
|
8522
|
+
m.exports = result;
|
8523
|
+
if (id) {
|
8524
|
+
loaderCache[id] = m.exports;
|
8525
|
+
}
|
8526
|
+
}
|
8527
|
+
}
|
8528
|
+
|
8529
|
+
stringRequire = function (systemRequire, exports, module, id, relId) {
|
8530
|
+
//Split the ID by a ! so that
|
8531
|
+
var index = id.indexOf('!'),
|
8532
|
+
originalId = id,
|
8533
|
+
prefix, plugin;
|
8534
|
+
|
8535
|
+
if (index === -1) {
|
8536
|
+
id = normalize(id, relId);
|
8537
|
+
|
8538
|
+
//Straight module lookup. If it is one of the special dependencies,
|
8539
|
+
//deal with it, otherwise, delegate to node.
|
8540
|
+
if (id === 'require') {
|
8541
|
+
return makeRequire(systemRequire, exports, module, relId);
|
8542
|
+
} else if (id === 'exports') {
|
8543
|
+
return exports;
|
8544
|
+
} else if (id === 'module') {
|
8545
|
+
return module;
|
8546
|
+
} else if (loaderCache.hasOwnProperty(id)) {
|
8547
|
+
return loaderCache[id];
|
8548
|
+
} else if (defineCache[id]) {
|
8549
|
+
runFactory.apply(null, defineCache[id]);
|
8550
|
+
return loaderCache[id];
|
8551
|
+
} else {
|
8552
|
+
if(systemRequire) {
|
8553
|
+
return systemRequire(originalId);
|
8554
|
+
} else {
|
8555
|
+
throw new Error('No module with ID: ' + id);
|
8556
|
+
}
|
8557
|
+
}
|
8558
|
+
} else {
|
8559
|
+
//There is a plugin in play.
|
8560
|
+
prefix = id.substring(0, index);
|
8561
|
+
id = id.substring(index + 1, id.length);
|
8562
|
+
|
8563
|
+
plugin = stringRequire(systemRequire, exports, module, prefix, relId);
|
8564
|
+
|
8565
|
+
if (plugin.normalize) {
|
8566
|
+
id = plugin.normalize(id, makeNormalize(relId));
|
8567
|
+
} else {
|
8568
|
+
//Normalize the ID normally.
|
8569
|
+
id = normalize(id, relId);
|
8570
|
+
}
|
8571
|
+
|
8572
|
+
if (loaderCache[id]) {
|
8573
|
+
return loaderCache[id];
|
8574
|
+
} else {
|
8575
|
+
plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});
|
8576
|
+
|
8577
|
+
return loaderCache[id];
|
8578
|
+
}
|
8579
|
+
}
|
8580
|
+
};
|
8581
|
+
|
8582
|
+
//Create a define function specific to the module asking for amdefine.
|
8583
|
+
function define(id, deps, factory) {
|
8584
|
+
if (Array.isArray(id)) {
|
8585
|
+
factory = deps;
|
8586
|
+
deps = id;
|
8587
|
+
id = undefined;
|
8588
|
+
} else if (typeof id !== 'string') {
|
8589
|
+
factory = id;
|
8590
|
+
id = deps = undefined;
|
8591
|
+
}
|
8592
|
+
|
8593
|
+
if (deps && !Array.isArray(deps)) {
|
8594
|
+
factory = deps;
|
8595
|
+
deps = undefined;
|
8596
|
+
}
|
8597
|
+
|
8598
|
+
if (!deps) {
|
8599
|
+
deps = ['require', 'exports', 'module'];
|
8600
|
+
}
|
8601
|
+
|
8602
|
+
//Set up properties for this module. If an ID, then use
|
8603
|
+
//internal cache. If no ID, then use the external variables
|
8604
|
+
//for this node module.
|
8605
|
+
if (id) {
|
8606
|
+
//Put the module in deep freeze until there is a
|
8607
|
+
//require call for it.
|
8608
|
+
defineCache[id] = [id, deps, factory];
|
8609
|
+
} else {
|
8610
|
+
runFactory(id, deps, factory);
|
8611
|
+
}
|
8612
|
+
}
|
8613
|
+
|
8614
|
+
//define.require, which has access to all the values in the
|
8615
|
+
//cache. Useful for AMD modules that all have IDs in the file,
|
8616
|
+
//but need to finally export a value to node based on one of those
|
8617
|
+
//IDs.
|
8618
|
+
define.require = function (id) {
|
8619
|
+
if (loaderCache[id]) {
|
8620
|
+
return loaderCache[id];
|
8621
|
+
}
|
8622
|
+
|
8623
|
+
if (defineCache[id]) {
|
8624
|
+
runFactory.apply(null, defineCache[id]);
|
8625
|
+
return loaderCache[id];
|
8626
|
+
}
|
8627
|
+
};
|
8628
|
+
|
8629
|
+
define.amd = {};
|
8630
|
+
|
8631
|
+
return define;
|
8632
|
+
}
|
8633
|
+
|
8634
|
+
module.exports = amdefine;
|
8635
|
+
|
8636
|
+
}).call(this,require('_process'),"/node_modules/ng-annotate/node_modules/source-map/node_modules/amdefine/amdefine.js")
|
8637
|
+
},{"_process":7,"path":6}],29:[function(require,module,exports){
|
8638
|
+
//! stable.js 0.1.5, https://github.com/Two-Screen/stable
|
8639
|
+
//! © 2014 Angry Bytes and contributors. MIT licensed.
|
8640
|
+
|
8641
|
+
(function() {
|
8642
|
+
|
8643
|
+
// A stable array sort, because `Array#sort()` is not guaranteed stable.
|
8644
|
+
// This is an implementation of merge sort, without recursion.
|
8645
|
+
|
8646
|
+
var stable = function(arr, comp) {
|
8647
|
+
return exec(arr.slice(), comp);
|
8648
|
+
};
|
8649
|
+
|
8650
|
+
stable.inplace = function(arr, comp) {
|
8651
|
+
var result = exec(arr, comp);
|
8652
|
+
|
8653
|
+
// This simply copies back if the result isn't in the original array,
|
8654
|
+
// which happens on an odd number of passes.
|
8655
|
+
if (result !== arr) {
|
8656
|
+
pass(result, null, arr.length, arr);
|
8657
|
+
}
|
8658
|
+
|
8659
|
+
return arr;
|
8660
|
+
};
|
8661
|
+
|
8662
|
+
// Execute the sort using the input array and a second buffer as work space.
|
8663
|
+
// Returns one of those two, containing the final result.
|
8664
|
+
function exec(arr, comp) {
|
8665
|
+
if (typeof(comp) !== 'function') {
|
8666
|
+
comp = function(a, b) {
|
8667
|
+
return String(a).localeCompare(b);
|
8668
|
+
};
|
8669
|
+
}
|
8670
|
+
|
8671
|
+
// Short-circuit when there's nothing to sort.
|
8672
|
+
var len = arr.length;
|
8673
|
+
if (len <= 1) {
|
8674
|
+
return arr;
|
8675
|
+
}
|
8676
|
+
|
8677
|
+
// Rather than dividing input, simply iterate chunks of 1, 2, 4, 8, etc.
|
8678
|
+
// Chunks are the size of the left or right hand in merge sort.
|
8679
|
+
// Stop when the left-hand covers all of the array.
|
8680
|
+
var buffer = new Array(len);
|
8681
|
+
for (var chk = 1; chk < len; chk *= 2) {
|
8682
|
+
pass(arr, comp, chk, buffer);
|
8683
|
+
|
8684
|
+
var tmp = arr;
|
8685
|
+
arr = buffer;
|
8686
|
+
buffer = tmp;
|
8687
|
+
}
|
8688
|
+
|
8689
|
+
return arr;
|
8690
|
+
}
|
8691
|
+
|
8692
|
+
// Run a single pass with the given chunk size.
|
8693
|
+
var pass = function(arr, comp, chk, result) {
|
8694
|
+
var len = arr.length;
|
8695
|
+
var i = 0;
|
8696
|
+
// Step size / double chunk size.
|
8697
|
+
var dbl = chk * 2;
|
8698
|
+
// Bounds of the left and right chunks.
|
8699
|
+
var l, r, e;
|
8700
|
+
// Iterators over the left and right chunk.
|
8701
|
+
var li, ri;
|
8702
|
+
|
8703
|
+
// Iterate over pairs of chunks.
|
8704
|
+
for (l = 0; l < len; l += dbl) {
|
8705
|
+
r = l + chk;
|
8706
|
+
e = r + chk;
|
8707
|
+
if (r > len) r = len;
|
8708
|
+
if (e > len) e = len;
|
8709
|
+
|
8710
|
+
// Iterate both chunks in parallel.
|
8711
|
+
li = l;
|
8712
|
+
ri = r;
|
8713
|
+
while (true) {
|
8714
|
+
// Compare the chunks.
|
8715
|
+
if (li < r && ri < e) {
|
8716
|
+
// This works for a regular `sort()` compatible comparator,
|
8717
|
+
// but also for a simple comparator like: `a > b`
|
8718
|
+
if (comp(arr[li], arr[ri]) <= 0) {
|
8719
|
+
result[i++] = arr[li++];
|
8720
|
+
}
|
8721
|
+
else {
|
8722
|
+
result[i++] = arr[ri++];
|
8723
|
+
}
|
8724
|
+
}
|
8725
|
+
// Nothing to compare, just flush what's left.
|
8726
|
+
else if (li < r) {
|
8727
|
+
result[i++] = arr[li++];
|
8728
|
+
}
|
8729
|
+
else if (ri < e) {
|
8730
|
+
result[i++] = arr[ri++];
|
8731
|
+
}
|
8732
|
+
// Both iterators are at the chunk ends.
|
8733
|
+
else {
|
8734
|
+
break;
|
8735
|
+
}
|
8736
|
+
}
|
8737
|
+
}
|
8738
|
+
};
|
8739
|
+
|
8740
|
+
// Export using CommonJS or to the window.
|
8741
|
+
if (typeof(module) !== 'undefined') {
|
8742
|
+
module.exports = stable;
|
8743
|
+
}
|
8744
|
+
else {
|
8745
|
+
window.stable = stable;
|
8746
|
+
}
|
8747
|
+
|
8748
|
+
})();
|
8749
|
+
|
8750
|
+
},{}]},{},[10]);
|