4581 lines
128 KiB
JavaScript
4581 lines
128 KiB
JavaScript
(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:[function(require,module,exports){
|
|
(function (process){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
// resolves . and .. elements in a path array with directory names there
|
|
// must be no slashes, empty elements, or device names (c:\) in the array
|
|
// (so also no leading and trailing slashes - it does not distinguish
|
|
// relative and absolute paths)
|
|
function normalizeArray(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var last = parts[i];
|
|
if (last === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (last === '..') {
|
|
parts.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
parts.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (allowAboveRoot) {
|
|
for (; up--; up) {
|
|
parts.unshift('..');
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
// Split a filename into [root, dir, basename, ext], unix version
|
|
// 'root' is just a slash, or nothing.
|
|
var splitPathRe =
|
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
|
var splitPath = function(filename) {
|
|
return splitPathRe.exec(filename).slice(1);
|
|
};
|
|
|
|
// path.resolve([from ...], to)
|
|
// posix version
|
|
exports.resolve = function() {
|
|
var resolvedPath = '',
|
|
resolvedAbsolute = false;
|
|
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
var path = (i >= 0) ? arguments[i] : process.cwd();
|
|
|
|
// Skip empty and invalid entries
|
|
if (typeof path !== 'string') {
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
|
} else if (!path) {
|
|
continue;
|
|
}
|
|
|
|
resolvedPath = path + '/' + resolvedPath;
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
|
}
|
|
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
|
|
// Normalize the path
|
|
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
|
|
return !!p;
|
|
}), !resolvedAbsolute).join('/');
|
|
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
|
};
|
|
|
|
// path.normalize(path)
|
|
// posix version
|
|
exports.normalize = function(path) {
|
|
var isAbsolute = exports.isAbsolute(path),
|
|
trailingSlash = substr(path, -1) === '/';
|
|
|
|
// Normalize the path
|
|
path = normalizeArray(filter(path.split('/'), function(p) {
|
|
return !!p;
|
|
}), !isAbsolute).join('/');
|
|
|
|
if (!path && !isAbsolute) {
|
|
path = '.';
|
|
}
|
|
if (path && trailingSlash) {
|
|
path += '/';
|
|
}
|
|
|
|
return (isAbsolute ? '/' : '') + path;
|
|
};
|
|
|
|
// posix version
|
|
exports.isAbsolute = function(path) {
|
|
return path.charAt(0) === '/';
|
|
};
|
|
|
|
// posix version
|
|
exports.join = function() {
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
|
return exports.normalize(filter(paths, function(p, index) {
|
|
if (typeof p !== 'string') {
|
|
throw new TypeError('Arguments to path.join must be strings');
|
|
}
|
|
return p;
|
|
}).join('/'));
|
|
};
|
|
|
|
|
|
// path.relative(from, to)
|
|
// posix version
|
|
exports.relative = function(from, to) {
|
|
from = exports.resolve(from).substr(1);
|
|
to = exports.resolve(to).substr(1);
|
|
|
|
function trim(arr) {
|
|
var start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') break;
|
|
}
|
|
|
|
var end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') break;
|
|
}
|
|
|
|
if (start > end) return [];
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
|
|
var fromParts = trim(from.split('/'));
|
|
var toParts = trim(to.split('/'));
|
|
|
|
var length = Math.min(fromParts.length, toParts.length);
|
|
var samePartsLength = length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var outputParts = [];
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
|
|
return outputParts.join('/');
|
|
};
|
|
|
|
exports.sep = '/';
|
|
exports.delimiter = ':';
|
|
|
|
exports.dirname = function(path) {
|
|
var result = splitPath(path),
|
|
root = result[0],
|
|
dir = result[1];
|
|
|
|
if (!root && !dir) {
|
|
// No dirname whatsoever
|
|
return '.';
|
|
}
|
|
|
|
if (dir) {
|
|
// It has a dirname, strip trailing slash
|
|
dir = dir.substr(0, dir.length - 1);
|
|
}
|
|
|
|
return root + dir;
|
|
};
|
|
|
|
|
|
exports.basename = function(path, ext) {
|
|
var f = splitPath(path)[2];
|
|
// TODO: make this comparison case-insensitive on windows?
|
|
if (ext && f.substr(-1 * ext.length) === ext) {
|
|
f = f.substr(0, f.length - ext.length);
|
|
}
|
|
return f;
|
|
};
|
|
|
|
|
|
exports.extname = function(path) {
|
|
return splitPath(path)[3];
|
|
};
|
|
|
|
function filter (xs, f) {
|
|
if (xs.filter) return xs.filter(f);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (f(xs[i], i, xs)) res.push(xs[i]);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// String.prototype.substr - negative index don't work in IE8
|
|
var substr = 'ab'.substr(-1) === 'b'
|
|
? function (str, start, len) { return str.substr(start, len) }
|
|
: function (str, start, len) {
|
|
if (start < 0) start = str.length + start;
|
|
return str.substr(start, len);
|
|
}
|
|
;
|
|
|
|
}).call(this,require('_process'))
|
|
},{"_process":3}],3:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
var process = module.exports = {};
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
var cachedSetTimeout;
|
|
var cachedClearTimeout;
|
|
|
|
function defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} catch(e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
} catch(e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
function runClearTimeout(marker) {
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
//normal enviroments in sane situations
|
|
return clearTimeout(marker);
|
|
}
|
|
// if clearTimeout wasn't available but was latter defined
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
cachedClearTimeout = clearTimeout;
|
|
return clearTimeout(marker);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedClearTimeout(marker);
|
|
} catch (e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedClearTimeout.call(null, marker);
|
|
} catch (e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
return cachedClearTimeout.call(this, marker);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
var queue = [];
|
|
var draining = false;
|
|
var currentQueue;
|
|
var queueIndex = -1;
|
|
|
|
function cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
process.nextTick = function (fun) {
|
|
var args = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
}
|
|
queue.push(new Item(fun, args));
|
|
if (queue.length === 1 && !draining) {
|
|
runTimeout(drainQueue);
|
|
}
|
|
};
|
|
|
|
// v8 likes predictible objects
|
|
function Item(fun, array) {
|
|
this.fun = fun;
|
|
this.array = array;
|
|
}
|
|
Item.prototype.run = function () {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
process.versions = {};
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
process.prependListener = noop;
|
|
process.prependOnceListener = noop;
|
|
|
|
process.listeners = function (name) { return [] }
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
};
|
|
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
process.umask = function() { return 0; };
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
//This is for browserify to build the required CSS module into something we can use in the browser.
|
|
window.css = require('css');
|
|
|
|
},{"css":6}],5:[function(require,module,exports){
|
|
(function (process,__filename){
|
|
/** vim: et:ts=4:sw=4:sts=4
|
|
* @license amdefine 1.0.1 Copyright (c) 2011-2016, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/jrburke/amdefine for details
|
|
*/
|
|
|
|
/*jslint node: true */
|
|
/*global module, process */
|
|
'use strict';
|
|
|
|
/**
|
|
* Creates a define for node.
|
|
* @param {Object} module the "module" object that is defined by Node for the
|
|
* current module.
|
|
* @param {Function} [requireFn]. Node's require function for the current module.
|
|
* It only needs to be passed in Node versions before 0.5, when module.require
|
|
* did not exist.
|
|
* @returns {Function} a define function that is usable for the current node
|
|
* module.
|
|
*/
|
|
function amdefine(module, requireFn) {
|
|
'use strict';
|
|
var defineCache = {},
|
|
loaderCache = {},
|
|
alreadyCalled = false,
|
|
path = require('path'),
|
|
makeRequire, stringRequire;
|
|
|
|
/**
|
|
* Trims the . and .. from an array of path segments.
|
|
* It will keep a leading path segment if a .. will become
|
|
* the first path segment, to help with module name lookups,
|
|
* which act like paths, but can be remapped. But the end result,
|
|
* all paths that use this function should look normalized.
|
|
* NOTE: this method MODIFIES the input array.
|
|
* @param {Array} ary the array of path segments.
|
|
*/
|
|
function trimDots(ary) {
|
|
var i, part;
|
|
for (i = 0; ary[i]; i+= 1) {
|
|
part = ary[i];
|
|
if (part === '.') {
|
|
ary.splice(i, 1);
|
|
i -= 1;
|
|
} else if (part === '..') {
|
|
if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
|
|
//End of the line. Keep at least one non-dot
|
|
//path segment at the front so it can be mapped
|
|
//correctly to disk. Otherwise, there is likely
|
|
//no path mapping for a path starting with '..'.
|
|
//This can still fail, but catches the most reasonable
|
|
//uses of ..
|
|
break;
|
|
} else if (i > 0) {
|
|
ary.splice(i - 1, 2);
|
|
i -= 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalize(name, baseName) {
|
|
var baseParts;
|
|
|
|
//Adjust any relative paths.
|
|
if (name && name.charAt(0) === '.') {
|
|
//If have a base name, try to normalize against it,
|
|
//otherwise, assume it is a top-level require that will
|
|
//be relative to baseUrl in the end.
|
|
if (baseName) {
|
|
baseParts = baseName.split('/');
|
|
baseParts = baseParts.slice(0, baseParts.length - 1);
|
|
baseParts = baseParts.concat(name.split('/'));
|
|
trimDots(baseParts);
|
|
name = baseParts.join('/');
|
|
}
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Create the normalize() function passed to a loader plugin's
|
|
* normalize method.
|
|
*/
|
|
function makeNormalize(relName) {
|
|
return function (name) {
|
|
return normalize(name, relName);
|
|
};
|
|
}
|
|
|
|
function makeLoad(id) {
|
|
function load(value) {
|
|
loaderCache[id] = value;
|
|
}
|
|
|
|
load.fromText = function (id, text) {
|
|
//This one is difficult because the text can/probably uses
|
|
//define, and any relative paths and requires should be relative
|
|
//to that id was it would be found on disk. But this would require
|
|
//bootstrapping a module/require fairly deeply from node core.
|
|
//Not sure how best to go about that yet.
|
|
throw new Error('amdefine does not implement load.fromText');
|
|
};
|
|
|
|
return load;
|
|
}
|
|
|
|
makeRequire = function (systemRequire, exports, module, relId) {
|
|
function amdRequire(deps, callback) {
|
|
if (typeof deps === 'string') {
|
|
//Synchronous, single module require('')
|
|
return stringRequire(systemRequire, exports, module, deps, relId);
|
|
} else {
|
|
//Array of dependencies with a callback.
|
|
|
|
//Convert the dependencies to modules.
|
|
deps = deps.map(function (depName) {
|
|
return stringRequire(systemRequire, exports, module, depName, relId);
|
|
});
|
|
|
|
//Wait for next tick to call back the require call.
|
|
if (callback) {
|
|
process.nextTick(function () {
|
|
callback.apply(null, deps);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
amdRequire.toUrl = function (filePath) {
|
|
if (filePath.indexOf('.') === 0) {
|
|
return normalize(filePath, path.dirname(module.filename));
|
|
} else {
|
|
return filePath;
|
|
}
|
|
};
|
|
|
|
return amdRequire;
|
|
};
|
|
|
|
//Favor explicit value, passed in if the module wants to support Node 0.4.
|
|
requireFn = requireFn || function req() {
|
|
return module.require.apply(module, arguments);
|
|
};
|
|
|
|
function runFactory(id, deps, factory) {
|
|
var r, e, m, result;
|
|
|
|
if (id) {
|
|
e = loaderCache[id] = {};
|
|
m = {
|
|
id: id,
|
|
uri: __filename,
|
|
exports: e
|
|
};
|
|
r = makeRequire(requireFn, e, m, id);
|
|
} else {
|
|
//Only support one define call per file
|
|
if (alreadyCalled) {
|
|
throw new Error('amdefine with no module ID cannot be called more than once per file.');
|
|
}
|
|
alreadyCalled = true;
|
|
|
|
//Use the real variables from node
|
|
//Use module.exports for exports, since
|
|
//the exports in here is amdefine exports.
|
|
e = module.exports;
|
|
m = module;
|
|
r = makeRequire(requireFn, e, m, module.id);
|
|
}
|
|
|
|
//If there are dependencies, they are strings, so need
|
|
//to convert them to dependency values.
|
|
if (deps) {
|
|
deps = deps.map(function (depName) {
|
|
return r(depName);
|
|
});
|
|
}
|
|
|
|
//Call the factory with the right dependencies.
|
|
if (typeof factory === 'function') {
|
|
result = factory.apply(m.exports, deps);
|
|
} else {
|
|
result = factory;
|
|
}
|
|
|
|
if (result !== undefined) {
|
|
m.exports = result;
|
|
if (id) {
|
|
loaderCache[id] = m.exports;
|
|
}
|
|
}
|
|
}
|
|
|
|
stringRequire = function (systemRequire, exports, module, id, relId) {
|
|
//Split the ID by a ! so that
|
|
var index = id.indexOf('!'),
|
|
originalId = id,
|
|
prefix, plugin;
|
|
|
|
if (index === -1) {
|
|
id = normalize(id, relId);
|
|
|
|
//Straight module lookup. If it is one of the special dependencies,
|
|
//deal with it, otherwise, delegate to node.
|
|
if (id === 'require') {
|
|
return makeRequire(systemRequire, exports, module, relId);
|
|
} else if (id === 'exports') {
|
|
return exports;
|
|
} else if (id === 'module') {
|
|
return module;
|
|
} else if (loaderCache.hasOwnProperty(id)) {
|
|
return loaderCache[id];
|
|
} else if (defineCache[id]) {
|
|
runFactory.apply(null, defineCache[id]);
|
|
return loaderCache[id];
|
|
} else {
|
|
if(systemRequire) {
|
|
return systemRequire(originalId);
|
|
} else {
|
|
throw new Error('No module with ID: ' + id);
|
|
}
|
|
}
|
|
} else {
|
|
//There is a plugin in play.
|
|
prefix = id.substring(0, index);
|
|
id = id.substring(index + 1, id.length);
|
|
|
|
plugin = stringRequire(systemRequire, exports, module, prefix, relId);
|
|
|
|
if (plugin.normalize) {
|
|
id = plugin.normalize(id, makeNormalize(relId));
|
|
} else {
|
|
//Normalize the ID normally.
|
|
id = normalize(id, relId);
|
|
}
|
|
|
|
if (loaderCache[id]) {
|
|
return loaderCache[id];
|
|
} else {
|
|
plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});
|
|
|
|
return loaderCache[id];
|
|
}
|
|
}
|
|
};
|
|
|
|
//Create a define function specific to the module asking for amdefine.
|
|
function define(id, deps, factory) {
|
|
if (Array.isArray(id)) {
|
|
factory = deps;
|
|
deps = id;
|
|
id = undefined;
|
|
} else if (typeof id !== 'string') {
|
|
factory = id;
|
|
id = deps = undefined;
|
|
}
|
|
|
|
if (deps && !Array.isArray(deps)) {
|
|
factory = deps;
|
|
deps = undefined;
|
|
}
|
|
|
|
if (!deps) {
|
|
deps = ['require', 'exports', 'module'];
|
|
}
|
|
|
|
//Set up properties for this module. If an ID, then use
|
|
//internal cache. If no ID, then use the external variables
|
|
//for this node module.
|
|
if (id) {
|
|
//Put the module in deep freeze until there is a
|
|
//require call for it.
|
|
defineCache[id] = [id, deps, factory];
|
|
} else {
|
|
runFactory(id, deps, factory);
|
|
}
|
|
}
|
|
|
|
//define.require, which has access to all the values in the
|
|
//cache. Useful for AMD modules that all have IDs in the file,
|
|
//but need to finally export a value to node based on one of those
|
|
//IDs.
|
|
define.require = function (id) {
|
|
if (loaderCache[id]) {
|
|
return loaderCache[id];
|
|
}
|
|
|
|
if (defineCache[id]) {
|
|
runFactory.apply(null, defineCache[id]);
|
|
return loaderCache[id];
|
|
}
|
|
};
|
|
|
|
define.amd = {};
|
|
|
|
return define;
|
|
}
|
|
|
|
module.exports = amdefine;
|
|
|
|
}).call(this,require('_process'),"/node_modules\\amdefine\\amdefine.js")
|
|
},{"_process":3,"path":2}],6:[function(require,module,exports){
|
|
exports.parse = require('./lib/parse');
|
|
exports.stringify = require('./lib/stringify');
|
|
|
|
},{"./lib/parse":7,"./lib/stringify":11}],7:[function(require,module,exports){
|
|
// http://www.w3.org/TR/CSS21/grammar.html
|
|
// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
|
|
var commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g
|
|
|
|
module.exports = function(css, options){
|
|
options = options || {};
|
|
|
|
/**
|
|
* Positional.
|
|
*/
|
|
|
|
var lineno = 1;
|
|
var column = 1;
|
|
|
|
/**
|
|
* Update lineno and column based on `str`.
|
|
*/
|
|
|
|
function updatePosition(str) {
|
|
var lines = str.match(/\n/g);
|
|
if (lines) lineno += lines.length;
|
|
var i = str.lastIndexOf('\n');
|
|
column = ~i ? str.length - i : column + str.length;
|
|
}
|
|
|
|
/**
|
|
* Mark position and patch `node.position`.
|
|
*/
|
|
|
|
function position() {
|
|
var start = { line: lineno, column: column };
|
|
return function(node){
|
|
node.position = new Position(start);
|
|
whitespace();
|
|
return node;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Store position information for a node
|
|
*/
|
|
|
|
function Position(start) {
|
|
this.start = start;
|
|
this.end = { line: lineno, column: column };
|
|
this.source = options.source;
|
|
}
|
|
|
|
/**
|
|
* Non-enumerable source string
|
|
*/
|
|
|
|
Position.prototype.content = css;
|
|
|
|
/**
|
|
* Error `msg`.
|
|
*/
|
|
|
|
var errorsList = [];
|
|
|
|
function error(msg) {
|
|
var err = new Error(options.source + ':' + lineno + ':' + column + ': ' + msg);
|
|
err.reason = msg;
|
|
err.filename = options.source;
|
|
err.line = lineno;
|
|
err.column = column;
|
|
err.source = css;
|
|
|
|
if (options.silent) {
|
|
errorsList.push(err);
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse stylesheet.
|
|
*/
|
|
|
|
function stylesheet() {
|
|
var rulesList = rules();
|
|
|
|
return {
|
|
type: 'stylesheet',
|
|
stylesheet: {
|
|
rules: rulesList,
|
|
parsingErrors: errorsList
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Opening brace.
|
|
*/
|
|
|
|
function open() {
|
|
return match(/^{\s*/);
|
|
}
|
|
|
|
/**
|
|
* Closing brace.
|
|
*/
|
|
|
|
function close() {
|
|
return match(/^}/);
|
|
}
|
|
|
|
/**
|
|
* Parse ruleset.
|
|
*/
|
|
|
|
function rules() {
|
|
var node;
|
|
var rules = [];
|
|
whitespace();
|
|
comments(rules);
|
|
while (css.length && css.charAt(0) != '}' && (node = atrule() || rule())) {
|
|
if (node !== false) {
|
|
rules.push(node);
|
|
comments(rules);
|
|
}
|
|
}
|
|
return rules;
|
|
}
|
|
|
|
/**
|
|
* Match `re` and return captures.
|
|
*/
|
|
|
|
function match(re) {
|
|
var m = re.exec(css);
|
|
if (!m) return;
|
|
var str = m[0];
|
|
updatePosition(str);
|
|
css = css.slice(str.length);
|
|
return m;
|
|
}
|
|
|
|
/**
|
|
* Parse whitespace.
|
|
*/
|
|
|
|
function whitespace() {
|
|
match(/^\s*/);
|
|
}
|
|
|
|
/**
|
|
* Parse comments;
|
|
*/
|
|
|
|
function comments(rules) {
|
|
var c;
|
|
rules = rules || [];
|
|
while (c = comment()) {
|
|
if (c !== false) {
|
|
rules.push(c);
|
|
}
|
|
}
|
|
return rules;
|
|
}
|
|
|
|
/**
|
|
* Parse comment.
|
|
*/
|
|
|
|
function comment() {
|
|
var pos = position();
|
|
if ('/' != css.charAt(0) || '*' != css.charAt(1)) return;
|
|
|
|
var i = 2;
|
|
while ("" != css.charAt(i) && ('*' != css.charAt(i) || '/' != css.charAt(i + 1))) ++i;
|
|
i += 2;
|
|
|
|
if ("" === css.charAt(i-1)) {
|
|
return error('End of comment missing');
|
|
}
|
|
|
|
var str = css.slice(2, i - 2);
|
|
column += 2;
|
|
updatePosition(str);
|
|
css = css.slice(i);
|
|
column += 2;
|
|
|
|
return pos({
|
|
type: 'comment',
|
|
comment: str
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse selector.
|
|
*/
|
|
|
|
function selector() {
|
|
var m = match(/^([^{]+)/);
|
|
if (!m) return;
|
|
/* @fix Remove all comments from selectors
|
|
* http://ostermiller.org/findcomment.html */
|
|
return trim(m[0])
|
|
.replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, '')
|
|
.replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function(m) {
|
|
return m.replace(/,/g, '\u200C');
|
|
})
|
|
.split(/\s*(?![^(]*\)),\s*/)
|
|
.map(function(s) {
|
|
return s.replace(/\u200C/g, ',');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse declaration.
|
|
*/
|
|
|
|
function declaration() {
|
|
var pos = position();
|
|
|
|
// prop
|
|
var prop = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
|
|
if (!prop) return;
|
|
prop = trim(prop[0]);
|
|
|
|
// :
|
|
if (!match(/^:\s*/)) return error("property missing ':'");
|
|
|
|
// val
|
|
var val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/);
|
|
|
|
var ret = pos({
|
|
type: 'declaration',
|
|
property: prop.replace(commentre, ''),
|
|
value: val ? trim(val[0]).replace(commentre, '') : ''
|
|
});
|
|
|
|
// ;
|
|
match(/^[;\s]*/);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Parse declarations.
|
|
*/
|
|
|
|
function declarations() {
|
|
var decls = [];
|
|
|
|
if (!open()) return error("missing '{'");
|
|
comments(decls);
|
|
|
|
// declarations
|
|
var decl;
|
|
while (decl = declaration()) {
|
|
if (decl !== false) {
|
|
decls.push(decl);
|
|
comments(decls);
|
|
}
|
|
}
|
|
|
|
if (!close()) return error("missing '}'");
|
|
return decls;
|
|
}
|
|
|
|
/**
|
|
* Parse keyframe.
|
|
*/
|
|
|
|
function keyframe() {
|
|
var m;
|
|
var vals = [];
|
|
var pos = position();
|
|
|
|
while (m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)) {
|
|
vals.push(m[1]);
|
|
match(/^,\s*/);
|
|
}
|
|
|
|
if (!vals.length) return;
|
|
|
|
return pos({
|
|
type: 'keyframe',
|
|
values: vals,
|
|
declarations: declarations()
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse keyframes.
|
|
*/
|
|
|
|
function atkeyframes() {
|
|
var pos = position();
|
|
var m = match(/^@([-\w]+)?keyframes\s*/);
|
|
|
|
if (!m) return;
|
|
var vendor = m[1];
|
|
|
|
// identifier
|
|
var m = match(/^([-\w]+)\s*/);
|
|
if (!m) return error("@keyframes missing name");
|
|
var name = m[1];
|
|
|
|
if (!open()) return error("@keyframes missing '{'");
|
|
|
|
var frame;
|
|
var frames = comments();
|
|
while (frame = keyframe()) {
|
|
frames.push(frame);
|
|
frames = frames.concat(comments());
|
|
}
|
|
|
|
if (!close()) return error("@keyframes missing '}'");
|
|
|
|
return pos({
|
|
type: 'keyframes',
|
|
name: name,
|
|
vendor: vendor,
|
|
keyframes: frames
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse supports.
|
|
*/
|
|
|
|
function atsupports() {
|
|
var pos = position();
|
|
var m = match(/^@supports *([^{]+)/);
|
|
|
|
if (!m) return;
|
|
var supports = trim(m[1]);
|
|
|
|
if (!open()) return error("@supports missing '{'");
|
|
|
|
var style = comments().concat(rules());
|
|
|
|
if (!close()) return error("@supports missing '}'");
|
|
|
|
return pos({
|
|
type: 'supports',
|
|
supports: supports,
|
|
rules: style
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse host.
|
|
*/
|
|
|
|
function athost() {
|
|
var pos = position();
|
|
var m = match(/^@host\s*/);
|
|
|
|
if (!m) return;
|
|
|
|
if (!open()) return error("@host missing '{'");
|
|
|
|
var style = comments().concat(rules());
|
|
|
|
if (!close()) return error("@host missing '}'");
|
|
|
|
return pos({
|
|
type: 'host',
|
|
rules: style
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse media.
|
|
*/
|
|
|
|
function atmedia() {
|
|
var pos = position();
|
|
var m = match(/^@media *([^{]+)/);
|
|
|
|
if (!m) return;
|
|
var media = trim(m[1]);
|
|
|
|
if (!open()) return error("@media missing '{'");
|
|
|
|
var style = comments().concat(rules());
|
|
|
|
if (!close()) return error("@media missing '}'");
|
|
|
|
return pos({
|
|
type: 'media',
|
|
media: media,
|
|
rules: style
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Parse custom-media.
|
|
*/
|
|
|
|
function atcustommedia() {
|
|
var pos = position();
|
|
var m = match(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/);
|
|
if (!m) return;
|
|
|
|
return pos({
|
|
type: 'custom-media',
|
|
name: trim(m[1]),
|
|
media: trim(m[2])
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse paged media.
|
|
*/
|
|
|
|
function atpage() {
|
|
var pos = position();
|
|
var m = match(/^@page */);
|
|
if (!m) return;
|
|
|
|
var sel = selector() || [];
|
|
|
|
if (!open()) return error("@page missing '{'");
|
|
var decls = comments();
|
|
|
|
// declarations
|
|
var decl;
|
|
while (decl = declaration()) {
|
|
decls.push(decl);
|
|
decls = decls.concat(comments());
|
|
}
|
|
|
|
if (!close()) return error("@page missing '}'");
|
|
|
|
return pos({
|
|
type: 'page',
|
|
selectors: sel,
|
|
declarations: decls
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse document.
|
|
*/
|
|
|
|
function atdocument() {
|
|
var pos = position();
|
|
var m = match(/^@([-\w]+)?document *([^{]+)/);
|
|
if (!m) return;
|
|
|
|
var vendor = trim(m[1]);
|
|
var doc = trim(m[2]);
|
|
|
|
if (!open()) return error("@document missing '{'");
|
|
|
|
var style = comments().concat(rules());
|
|
|
|
if (!close()) return error("@document missing '}'");
|
|
|
|
return pos({
|
|
type: 'document',
|
|
document: doc,
|
|
vendor: vendor,
|
|
rules: style
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse font-face.
|
|
*/
|
|
|
|
function atfontface() {
|
|
var pos = position();
|
|
var m = match(/^@font-face\s*/);
|
|
if (!m) return;
|
|
|
|
if (!open()) return error("@font-face missing '{'");
|
|
var decls = comments();
|
|
|
|
// declarations
|
|
var decl;
|
|
while (decl = declaration()) {
|
|
decls.push(decl);
|
|
decls = decls.concat(comments());
|
|
}
|
|
|
|
if (!close()) return error("@font-face missing '}'");
|
|
|
|
return pos({
|
|
type: 'font-face',
|
|
declarations: decls
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse import
|
|
*/
|
|
|
|
var atimport = _compileAtrule('import');
|
|
|
|
/**
|
|
* Parse charset
|
|
*/
|
|
|
|
var atcharset = _compileAtrule('charset');
|
|
|
|
/**
|
|
* Parse namespace
|
|
*/
|
|
|
|
var atnamespace = _compileAtrule('namespace');
|
|
|
|
/**
|
|
* Parse non-block at-rules
|
|
*/
|
|
|
|
|
|
function _compileAtrule(name) {
|
|
var re = new RegExp('^@' + name + '\\s*([^;]+);');
|
|
return function() {
|
|
var pos = position();
|
|
var m = match(re);
|
|
if (!m) return;
|
|
var ret = { type: name };
|
|
ret[name] = m[1].trim();
|
|
return pos(ret);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse at rule.
|
|
*/
|
|
|
|
function atrule() {
|
|
if (css[0] != '@') return;
|
|
|
|
return atkeyframes()
|
|
|| atmedia()
|
|
|| atcustommedia()
|
|
|| atsupports()
|
|
|| atimport()
|
|
|| atcharset()
|
|
|| atnamespace()
|
|
|| atdocument()
|
|
|| atpage()
|
|
|| athost()
|
|
|| atfontface();
|
|
}
|
|
|
|
/**
|
|
* Parse rule.
|
|
*/
|
|
|
|
function rule() {
|
|
var pos = position();
|
|
var sel = selector();
|
|
|
|
if (!sel) return error('selector missing');
|
|
comments();
|
|
|
|
return pos({
|
|
type: 'rule',
|
|
selectors: sel,
|
|
declarations: declarations()
|
|
});
|
|
}
|
|
|
|
return addParent(stylesheet());
|
|
};
|
|
|
|
/**
|
|
* Trim `str`.
|
|
*/
|
|
|
|
function trim(str) {
|
|
return str ? str.replace(/^\s+|\s+$/g, '') : '';
|
|
}
|
|
|
|
/**
|
|
* Adds non-enumerable parent node reference to each node.
|
|
*/
|
|
|
|
function addParent(obj, parent) {
|
|
var isNode = obj && typeof obj.type === 'string';
|
|
var childParent = isNode ? obj : parent;
|
|
|
|
for (var k in obj) {
|
|
var value = obj[k];
|
|
if (Array.isArray(value)) {
|
|
value.forEach(function(v) { addParent(v, childParent); });
|
|
} else if (value && typeof value === 'object') {
|
|
addParent(value, childParent);
|
|
}
|
|
}
|
|
|
|
if (isNode) {
|
|
Object.defineProperty(obj, 'parent', {
|
|
configurable: true,
|
|
writable: true,
|
|
enumerable: false,
|
|
value: parent || null
|
|
});
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
|
|
/**
|
|
* Expose `Compiler`.
|
|
*/
|
|
|
|
module.exports = Compiler;
|
|
|
|
/**
|
|
* Initialize a compiler.
|
|
*
|
|
* @param {Type} name
|
|
* @return {Type}
|
|
* @api public
|
|
*/
|
|
|
|
function Compiler(opts) {
|
|
this.options = opts || {};
|
|
}
|
|
|
|
/**
|
|
* Emit `str`
|
|
*/
|
|
|
|
Compiler.prototype.emit = function(str) {
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Visit `node`.
|
|
*/
|
|
|
|
Compiler.prototype.visit = function(node){
|
|
return this[node.type](node);
|
|
};
|
|
|
|
/**
|
|
* Map visit over array of `nodes`, optionally using a `delim`
|
|
*/
|
|
|
|
Compiler.prototype.mapVisit = function(nodes, delim){
|
|
var buf = '';
|
|
delim = delim || '';
|
|
|
|
for (var i = 0, length = nodes.length; i < length; i++) {
|
|
buf += this.visit(nodes[i]);
|
|
if (delim && i < length - 1) buf += this.emit(delim);
|
|
}
|
|
|
|
return buf;
|
|
};
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var Base = require('./compiler');
|
|
var inherits = require('inherits');
|
|
|
|
/**
|
|
* Expose compiler.
|
|
*/
|
|
|
|
module.exports = Compiler;
|
|
|
|
/**
|
|
* Initialize a new `Compiler`.
|
|
*/
|
|
|
|
function Compiler(options) {
|
|
Base.call(this, options);
|
|
}
|
|
|
|
/**
|
|
* Inherit from `Base.prototype`.
|
|
*/
|
|
|
|
inherits(Compiler, Base);
|
|
|
|
/**
|
|
* Compile `node`.
|
|
*/
|
|
|
|
Compiler.prototype.compile = function(node){
|
|
return node.stylesheet
|
|
.rules.map(this.visit, this)
|
|
.join('');
|
|
};
|
|
|
|
/**
|
|
* Visit comment node.
|
|
*/
|
|
|
|
Compiler.prototype.comment = function(node){
|
|
return this.emit('', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit import node.
|
|
*/
|
|
|
|
Compiler.prototype.import = function(node){
|
|
return this.emit('@import ' + node.import + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit media node.
|
|
*/
|
|
|
|
Compiler.prototype.media = function(node){
|
|
return this.emit('@media ' + node.media, node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.rules)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit document node.
|
|
*/
|
|
|
|
Compiler.prototype.document = function(node){
|
|
var doc = '@' + (node.vendor || '') + 'document ' + node.document;
|
|
|
|
return this.emit(doc, node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.rules)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit charset node.
|
|
*/
|
|
|
|
Compiler.prototype.charset = function(node){
|
|
return this.emit('@charset ' + node.charset + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit namespace node.
|
|
*/
|
|
|
|
Compiler.prototype.namespace = function(node){
|
|
return this.emit('@namespace ' + node.namespace + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit supports node.
|
|
*/
|
|
|
|
Compiler.prototype.supports = function(node){
|
|
return this.emit('@supports ' + node.supports, node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.rules)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit keyframes node.
|
|
*/
|
|
|
|
Compiler.prototype.keyframes = function(node){
|
|
return this.emit('@'
|
|
+ (node.vendor || '')
|
|
+ 'keyframes '
|
|
+ node.name, node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.keyframes)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit keyframe node.
|
|
*/
|
|
|
|
Compiler.prototype.keyframe = function(node){
|
|
var decls = node.declarations;
|
|
|
|
return this.emit(node.values.join(','), node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(decls)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit page node.
|
|
*/
|
|
|
|
Compiler.prototype.page = function(node){
|
|
var sel = node.selectors.length
|
|
? node.selectors.join(', ')
|
|
: '';
|
|
|
|
return this.emit('@page ' + sel, node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.declarations)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit font-face node.
|
|
*/
|
|
|
|
Compiler.prototype['font-face'] = function(node){
|
|
return this.emit('@font-face', node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.declarations)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit host node.
|
|
*/
|
|
|
|
Compiler.prototype.host = function(node){
|
|
return this.emit('@host', node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(node.rules)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit custom-media node.
|
|
*/
|
|
|
|
Compiler.prototype['custom-media'] = function(node){
|
|
return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit rule node.
|
|
*/
|
|
|
|
Compiler.prototype.rule = function(node){
|
|
var decls = node.declarations;
|
|
if (!decls.length) return '';
|
|
|
|
return this.emit(node.selectors.join(','), node.position)
|
|
+ this.emit('{')
|
|
+ this.mapVisit(decls)
|
|
+ this.emit('}');
|
|
};
|
|
|
|
/**
|
|
* Visit declaration node.
|
|
*/
|
|
|
|
Compiler.prototype.declaration = function(node){
|
|
return this.emit(node.property + ':' + node.value, node.position) + this.emit(';');
|
|
};
|
|
|
|
|
|
},{"./compiler":8,"inherits":13}],10:[function(require,module,exports){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var Base = require('./compiler');
|
|
var inherits = require('inherits');
|
|
|
|
/**
|
|
* Expose compiler.
|
|
*/
|
|
|
|
module.exports = Compiler;
|
|
|
|
/**
|
|
* Initialize a new `Compiler`.
|
|
*/
|
|
|
|
function Compiler(options) {
|
|
options = options || {};
|
|
Base.call(this, options);
|
|
this.indentation = options.indent;
|
|
}
|
|
|
|
/**
|
|
* Inherit from `Base.prototype`.
|
|
*/
|
|
|
|
inherits(Compiler, Base);
|
|
|
|
/**
|
|
* Compile `node`.
|
|
*/
|
|
|
|
Compiler.prototype.compile = function(node){
|
|
return this.stylesheet(node);
|
|
};
|
|
|
|
/**
|
|
* Visit stylesheet node.
|
|
*/
|
|
|
|
Compiler.prototype.stylesheet = function(node){
|
|
return this.mapVisit(node.stylesheet.rules, '\n\n');
|
|
};
|
|
|
|
/**
|
|
* Visit comment node.
|
|
*/
|
|
|
|
Compiler.prototype.comment = function(node){
|
|
return this.emit(this.indent() + '/*' + node.comment + '*/', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit import node.
|
|
*/
|
|
|
|
Compiler.prototype.import = function(node){
|
|
return this.emit('@import ' + node.import + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit media node.
|
|
*/
|
|
|
|
Compiler.prototype.media = function(node){
|
|
return this.emit('@media ' + node.media, node.position)
|
|
+ this.emit(
|
|
' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(node.rules, '\n\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit document node.
|
|
*/
|
|
|
|
Compiler.prototype.document = function(node){
|
|
var doc = '@' + (node.vendor || '') + 'document ' + node.document;
|
|
|
|
return this.emit(doc, node.position)
|
|
+ this.emit(
|
|
' '
|
|
+ ' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(node.rules, '\n\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit charset node.
|
|
*/
|
|
|
|
Compiler.prototype.charset = function(node){
|
|
return this.emit('@charset ' + node.charset + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit namespace node.
|
|
*/
|
|
|
|
Compiler.prototype.namespace = function(node){
|
|
return this.emit('@namespace ' + node.namespace + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit supports node.
|
|
*/
|
|
|
|
Compiler.prototype.supports = function(node){
|
|
return this.emit('@supports ' + node.supports, node.position)
|
|
+ this.emit(
|
|
' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(node.rules, '\n\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit keyframes node.
|
|
*/
|
|
|
|
Compiler.prototype.keyframes = function(node){
|
|
return this.emit('@' + (node.vendor || '') + 'keyframes ' + node.name, node.position)
|
|
+ this.emit(
|
|
' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(node.keyframes, '\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '}');
|
|
};
|
|
|
|
/**
|
|
* Visit keyframe node.
|
|
*/
|
|
|
|
Compiler.prototype.keyframe = function(node){
|
|
var decls = node.declarations;
|
|
|
|
return this.emit(this.indent())
|
|
+ this.emit(node.values.join(', '), node.position)
|
|
+ this.emit(
|
|
' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(decls, '\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '\n'
|
|
+ this.indent() + '}\n');
|
|
};
|
|
|
|
/**
|
|
* Visit page node.
|
|
*/
|
|
|
|
Compiler.prototype.page = function(node){
|
|
var sel = node.selectors.length
|
|
? node.selectors.join(', ') + ' '
|
|
: '';
|
|
|
|
return this.emit('@page ' + sel, node.position)
|
|
+ this.emit('{\n')
|
|
+ this.emit(this.indent(1))
|
|
+ this.mapVisit(node.declarations, '\n')
|
|
+ this.emit(this.indent(-1))
|
|
+ this.emit('\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit font-face node.
|
|
*/
|
|
|
|
Compiler.prototype['font-face'] = function(node){
|
|
return this.emit('@font-face ', node.position)
|
|
+ this.emit('{\n')
|
|
+ this.emit(this.indent(1))
|
|
+ this.mapVisit(node.declarations, '\n')
|
|
+ this.emit(this.indent(-1))
|
|
+ this.emit('\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit host node.
|
|
*/
|
|
|
|
Compiler.prototype.host = function(node){
|
|
return this.emit('@host', node.position)
|
|
+ this.emit(
|
|
' {\n'
|
|
+ this.indent(1))
|
|
+ this.mapVisit(node.rules, '\n\n')
|
|
+ this.emit(
|
|
this.indent(-1)
|
|
+ '\n}');
|
|
};
|
|
|
|
/**
|
|
* Visit custom-media node.
|
|
*/
|
|
|
|
Compiler.prototype['custom-media'] = function(node){
|
|
return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position);
|
|
};
|
|
|
|
/**
|
|
* Visit rule node.
|
|
*/
|
|
|
|
Compiler.prototype.rule = function(node){
|
|
var indent = this.indent();
|
|
var decls = node.declarations;
|
|
if (!decls.length) return '';
|
|
|
|
return this.emit(node.selectors.map(function(s){ return indent + s }).join(',\n'), node.position)
|
|
+ this.emit(' {\n')
|
|
+ this.emit(this.indent(1))
|
|
+ this.mapVisit(decls, '\n')
|
|
+ this.emit(this.indent(-1))
|
|
+ this.emit('\n' + this.indent() + '}');
|
|
};
|
|
|
|
/**
|
|
* Visit declaration node.
|
|
*/
|
|
|
|
Compiler.prototype.declaration = function(node){
|
|
return this.emit(this.indent())
|
|
+ this.emit(node.property + ': ' + node.value, node.position)
|
|
+ this.emit(';');
|
|
};
|
|
|
|
/**
|
|
* Increase, decrease or return current indentation.
|
|
*/
|
|
|
|
Compiler.prototype.indent = function(level) {
|
|
this.level = this.level || 1;
|
|
|
|
if (null != level) {
|
|
this.level += level;
|
|
return '';
|
|
}
|
|
|
|
return Array(this.level).join(this.indentation || ' ');
|
|
};
|
|
|
|
},{"./compiler":8,"inherits":13}],11:[function(require,module,exports){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var Compressed = require('./compress');
|
|
var Identity = require('./identity');
|
|
|
|
/**
|
|
* Stringfy the given AST `node`.
|
|
*
|
|
* Options:
|
|
*
|
|
* - `compress` space-optimized output
|
|
* - `sourcemap` return an object with `.code` and `.map`
|
|
*
|
|
* @param {Object} node
|
|
* @param {Object} [options]
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
module.exports = function(node, options){
|
|
options = options || {};
|
|
|
|
var compiler = options.compress
|
|
? new Compressed(options)
|
|
: new Identity(options);
|
|
|
|
// source maps
|
|
if (options.sourcemap) {
|
|
var sourcemaps = require('./source-map-support');
|
|
sourcemaps(compiler);
|
|
|
|
var code = compiler.compile(node);
|
|
compiler.applySourceMaps();
|
|
|
|
var map = options.sourcemap === 'generator'
|
|
? compiler.map
|
|
: compiler.map.toJSON();
|
|
|
|
return { code: code, map: map };
|
|
}
|
|
|
|
var code = compiler.compile(node);
|
|
return code;
|
|
};
|
|
|
|
},{"./compress":9,"./identity":10,"./source-map-support":12}],12:[function(require,module,exports){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var SourceMap = require('source-map').SourceMapGenerator;
|
|
var SourceMapConsumer = require('source-map').SourceMapConsumer;
|
|
var sourceMapResolve = require('source-map-resolve');
|
|
var urix = require('urix');
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
|
|
/**
|
|
* Expose `mixin()`.
|
|
*/
|
|
|
|
module.exports = mixin;
|
|
|
|
/**
|
|
* Mixin source map support into `compiler`.
|
|
*
|
|
* @param {Compiler} compiler
|
|
* @api public
|
|
*/
|
|
|
|
function mixin(compiler) {
|
|
compiler._comment = compiler.comment;
|
|
compiler.map = new SourceMap();
|
|
compiler.position = { line: 1, column: 1 };
|
|
compiler.files = {};
|
|
for (var k in exports) compiler[k] = exports[k];
|
|
}
|
|
|
|
/**
|
|
* Update position.
|
|
*
|
|
* @param {String} str
|
|
* @api private
|
|
*/
|
|
|
|
exports.updatePosition = function(str) {
|
|
var lines = str.match(/\n/g);
|
|
if (lines) this.position.line += lines.length;
|
|
var i = str.lastIndexOf('\n');
|
|
this.position.column = ~i ? str.length - i : this.position.column + str.length;
|
|
};
|
|
|
|
/**
|
|
* Emit `str`.
|
|
*
|
|
* @param {String} str
|
|
* @param {Object} [pos]
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
exports.emit = function(str, pos) {
|
|
if (pos) {
|
|
var sourceFile = urix(pos.source || 'source.css');
|
|
|
|
this.map.addMapping({
|
|
source: sourceFile,
|
|
generated: {
|
|
line: this.position.line,
|
|
column: Math.max(this.position.column - 1, 0)
|
|
},
|
|
original: {
|
|
line: pos.start.line,
|
|
column: pos.start.column - 1
|
|
}
|
|
});
|
|
|
|
this.addFile(sourceFile, pos);
|
|
}
|
|
|
|
this.updatePosition(str);
|
|
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Adds a file to the source map output if it has not already been added
|
|
* @param {String} file
|
|
* @param {Object} pos
|
|
*/
|
|
|
|
exports.addFile = function(file, pos) {
|
|
if (typeof pos.content !== 'string') return;
|
|
if (Object.prototype.hasOwnProperty.call(this.files, file)) return;
|
|
|
|
this.files[file] = pos.content;
|
|
};
|
|
|
|
/**
|
|
* Applies any original source maps to the output and embeds the source file
|
|
* contents in the source map.
|
|
*/
|
|
|
|
exports.applySourceMaps = function() {
|
|
Object.keys(this.files).forEach(function(file) {
|
|
var content = this.files[file];
|
|
this.map.setSourceContent(file, content);
|
|
|
|
if (this.options.inputSourcemaps !== false) {
|
|
var originalMap = sourceMapResolve.resolveSync(
|
|
content, file, fs.readFileSync);
|
|
if (originalMap) {
|
|
var map = new SourceMapConsumer(originalMap.map);
|
|
var relativeTo = originalMap.sourcesRelativeTo;
|
|
this.map.applySourceMap(map, file, urix(path.dirname(relativeTo)));
|
|
}
|
|
}
|
|
}, this);
|
|
};
|
|
|
|
/**
|
|
* Process comments, drops sourceMap comments.
|
|
* @param {Object} node
|
|
*/
|
|
|
|
exports.comment = function(node) {
|
|
if (/^# sourceMappingURL=/.test(node.comment))
|
|
return this.emit('', node.position);
|
|
else
|
|
return this._comment(node);
|
|
};
|
|
|
|
},{"fs":1,"path":2,"source-map":17,"source-map-resolve":15,"urix":27}],13:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
// Copyright 2014 Simon Lydell
|
|
// X11 (“MIT”) Licensed. (See LICENSE.)
|
|
|
|
void (function(root, factory) {
|
|
if (typeof define === "function" && define.amd) {
|
|
define(factory)
|
|
} else if (typeof exports === "object") {
|
|
module.exports = factory()
|
|
} else {
|
|
root.resolveUrl = factory()
|
|
}
|
|
}(this, function() {
|
|
|
|
function resolveUrl(/* ...urls */) {
|
|
var numUrls = arguments.length
|
|
|
|
if (numUrls === 0) {
|
|
throw new Error("resolveUrl requires at least one argument; got none.")
|
|
}
|
|
|
|
var base = document.createElement("base")
|
|
base.href = arguments[0]
|
|
|
|
if (numUrls === 1) {
|
|
return base.href
|
|
}
|
|
|
|
var head = document.getElementsByTagName("head")[0]
|
|
head.insertBefore(base, head.firstChild)
|
|
|
|
var a = document.createElement("a")
|
|
var resolved
|
|
|
|
for (var index = 1; index < numUrls; index++) {
|
|
a.href = arguments[index]
|
|
resolved = a.href
|
|
base.href = resolved
|
|
}
|
|
|
|
head.removeChild(base)
|
|
|
|
return resolved
|
|
}
|
|
|
|
return resolveUrl
|
|
|
|
}));
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
// Copyright 2014 Simon Lydell
|
|
// X11 (“MIT”) Licensed. (See LICENSE.)
|
|
|
|
// Note: source-map-resolve.js is generated from source-map-resolve-node.js and
|
|
// source-map-resolve-template.js. Only edit the two latter files, _not_
|
|
// source-map-resolve.js!
|
|
|
|
void (function(root, factory) {
|
|
if (typeof define === "function" && define.amd) {
|
|
define(["source-map-url", "resolve-url"], factory)
|
|
} else if (typeof exports === "object") {
|
|
var sourceMappingURL = require("source-map-url")
|
|
var resolveUrl = require("resolve-url")
|
|
module.exports = factory(sourceMappingURL, resolveUrl)
|
|
} else {
|
|
root.sourceMapResolve = factory(root.sourceMappingURL, root.resolveUrl)
|
|
}
|
|
}(this, function(sourceMappingURL, resolveUrl) {
|
|
|
|
function callbackAsync(callback, error, result) {
|
|
setImmediate(function() { callback(error, result) })
|
|
}
|
|
|
|
function parseMapToJSON(string) {
|
|
return JSON.parse(string.replace(/^\)\]\}'/, ""))
|
|
}
|
|
|
|
|
|
|
|
function resolveSourceMap(code, codeUrl, read, callback) {
|
|
var mapData
|
|
try {
|
|
mapData = resolveSourceMapHelper(code, codeUrl)
|
|
} catch (error) {
|
|
return callbackAsync(callback, error)
|
|
}
|
|
if (!mapData || mapData.map) {
|
|
return callbackAsync(callback, null, mapData)
|
|
}
|
|
read(mapData.url, function(error, result) {
|
|
if (error) {
|
|
return callback(error)
|
|
}
|
|
try {
|
|
mapData.map = parseMapToJSON(String(result))
|
|
} catch (error) {
|
|
return callback(error)
|
|
}
|
|
callback(null, mapData)
|
|
})
|
|
}
|
|
|
|
function resolveSourceMapSync(code, codeUrl, read) {
|
|
var mapData = resolveSourceMapHelper(code, codeUrl)
|
|
if (!mapData || mapData.map) {
|
|
return mapData
|
|
}
|
|
mapData.map = parseMapToJSON(String(read(mapData.url)))
|
|
return mapData
|
|
}
|
|
|
|
var dataUriRegex = /^data:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
|
|
var jsonMimeTypeRegex = /^(?:application|text)\/json$/
|
|
|
|
function resolveSourceMapHelper(code, codeUrl) {
|
|
var url = sourceMappingURL.getFrom(code)
|
|
if (!url) {
|
|
return null
|
|
}
|
|
|
|
var dataUri = url.match(dataUriRegex)
|
|
if (dataUri) {
|
|
var mimeType = dataUri[1]
|
|
var lastParameter = dataUri[2]
|
|
var encoded = dataUri[3]
|
|
if (!jsonMimeTypeRegex.test(mimeType)) {
|
|
throw new Error("Unuseful data uri mime type: " + (mimeType || "text/plain"))
|
|
}
|
|
return {
|
|
sourceMappingURL: url,
|
|
url: null,
|
|
sourcesRelativeTo: codeUrl,
|
|
map: parseMapToJSON(lastParameter === ";base64" ? atob(encoded) : decodeURIComponent(encoded))
|
|
}
|
|
}
|
|
|
|
var mapUrl = resolveUrl(codeUrl, url)
|
|
return {
|
|
sourceMappingURL: url,
|
|
url: mapUrl,
|
|
sourcesRelativeTo: mapUrl,
|
|
map: null
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function resolveSources(map, mapUrl, read, options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options
|
|
options = {}
|
|
}
|
|
var pending = map.sources.length
|
|
var errored = false
|
|
var result = {
|
|
sourcesResolved: [],
|
|
sourcesContent: []
|
|
}
|
|
|
|
var done = function(error) {
|
|
if (errored) {
|
|
return
|
|
}
|
|
if (error) {
|
|
errored = true
|
|
return callback(error)
|
|
}
|
|
pending--
|
|
if (pending === 0) {
|
|
callback(null, result)
|
|
}
|
|
}
|
|
|
|
resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
|
|
result.sourcesResolved[index] = fullUrl
|
|
if (typeof sourceContent === "string") {
|
|
result.sourcesContent[index] = sourceContent
|
|
callbackAsync(done, null)
|
|
} else {
|
|
read(fullUrl, function(error, source) {
|
|
result.sourcesContent[index] = String(source)
|
|
done(error)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
function resolveSourcesSync(map, mapUrl, read, options) {
|
|
var result = {
|
|
sourcesResolved: [],
|
|
sourcesContent: []
|
|
}
|
|
resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
|
|
result.sourcesResolved[index] = fullUrl
|
|
if (read !== null) {
|
|
if (typeof sourceContent === "string") {
|
|
result.sourcesContent[index] = sourceContent
|
|
} else {
|
|
result.sourcesContent[index] = String(read(fullUrl))
|
|
}
|
|
}
|
|
})
|
|
return result
|
|
}
|
|
|
|
var endingSlash = /\/?$/
|
|
|
|
function resolveSourcesHelper(map, mapUrl, options, fn) {
|
|
options = options || {}
|
|
var fullUrl
|
|
var sourceContent
|
|
for (var index = 0, len = map.sources.length; index < len; index++) {
|
|
if (map.sourceRoot && !options.ignoreSourceRoot) {
|
|
// Make sure that the sourceRoot ends with a slash, so that `/scripts/subdir` becomes
|
|
// `/scripts/subdir/<source>`, not `/scripts/<source>`. Pointing to a file as source root
|
|
// does not make sense.
|
|
fullUrl = resolveUrl(mapUrl, map.sourceRoot.replace(endingSlash, "/"), map.sources[index])
|
|
} else {
|
|
fullUrl = resolveUrl(mapUrl, map.sources[index])
|
|
}
|
|
sourceContent = (map.sourcesContent || [])[index]
|
|
fn(fullUrl, sourceContent, index)
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function resolve(code, codeUrl, read, options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options
|
|
options = {}
|
|
}
|
|
resolveSourceMap(code, codeUrl, read, function(error, mapData) {
|
|
if (error) {
|
|
return callback(error)
|
|
}
|
|
if (!mapData) {
|
|
return callback(null, null)
|
|
}
|
|
resolveSources(mapData.map, mapData.sourcesRelativeTo, read, options, function(error, result) {
|
|
if (error) {
|
|
return callback(error)
|
|
}
|
|
mapData.sourcesResolved = result.sourcesResolved
|
|
mapData.sourcesContent = result.sourcesContent
|
|
callback(null, mapData)
|
|
})
|
|
})
|
|
}
|
|
|
|
function resolveSync(code, codeUrl, read, options) {
|
|
var mapData = resolveSourceMapSync(code, codeUrl, read)
|
|
if (!mapData) {
|
|
return null
|
|
}
|
|
var result = resolveSourcesSync(mapData.map, mapData.sourcesRelativeTo, read, options)
|
|
mapData.sourcesResolved = result.sourcesResolved
|
|
mapData.sourcesContent = result.sourcesContent
|
|
return mapData
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
resolveSourceMap: resolveSourceMap,
|
|
resolveSourceMapSync: resolveSourceMapSync,
|
|
resolveSources: resolveSources,
|
|
resolveSourcesSync: resolveSourcesSync,
|
|
resolve: resolve,
|
|
resolveSync: resolveSync
|
|
}
|
|
|
|
}));
|
|
|
|
},{"resolve-url":14,"source-map-url":16}],16:[function(require,module,exports){
|
|
// Copyright 2014 Simon Lydell
|
|
// X11 (“MIT”) Licensed. (See LICENSE.)
|
|
|
|
void (function(root, factory) {
|
|
if (typeof define === "function" && define.amd) {
|
|
define(factory)
|
|
} else if (typeof exports === "object") {
|
|
module.exports = factory()
|
|
} else {
|
|
root.sourceMappingURL = factory()
|
|
}
|
|
}(this, function() {
|
|
|
|
var innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/
|
|
|
|
var regex = RegExp(
|
|
"(?:" +
|
|
"/\\*" +
|
|
"(?:\\s*\r?\n(?://)?)?" +
|
|
"(?:" + innerRegex.source + ")" +
|
|
"\\s*" +
|
|
"\\*/" +
|
|
"|" +
|
|
"//(?:" + innerRegex.source + ")" +
|
|
")" +
|
|
"\\s*$"
|
|
)
|
|
|
|
return {
|
|
|
|
regex: regex,
|
|
_innerRegex: innerRegex,
|
|
|
|
getFrom: function(code) {
|
|
var match = code.match(regex)
|
|
return (match ? match[1] || match[2] || "" : null)
|
|
},
|
|
|
|
existsIn: function(code) {
|
|
return regex.test(code)
|
|
},
|
|
|
|
removeFrom: function(code) {
|
|
return code.replace(regex, "")
|
|
},
|
|
|
|
insertBefore: function(code, string) {
|
|
var match = code.match(regex)
|
|
if (match) {
|
|
return code.slice(0, match.index) + string + code.slice(match.index)
|
|
} else {
|
|
return code + string
|
|
}
|
|
}
|
|
}
|
|
|
|
}));
|
|
|
|
},{}],17:[function(require,module,exports){
|
|
/*
|
|
* Copyright 2009-2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE.txt or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
|
|
exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
|
|
exports.SourceNode = require('./source-map/source-node').SourceNode;
|
|
|
|
},{"./source-map/source-map-consumer":23,"./source-map/source-map-generator":24,"./source-map/source-node":25}],18:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var util = require('./util');
|
|
|
|
/**
|
|
* A data structure which is a combination of an array and a set. Adding a new
|
|
* member is O(1), testing for membership is O(1), and finding the index of an
|
|
* element is O(1). Removing elements from the set is not supported. Only
|
|
* strings are supported for membership.
|
|
*/
|
|
function ArraySet() {
|
|
this._array = [];
|
|
this._set = {};
|
|
}
|
|
|
|
/**
|
|
* Static method for creating ArraySet instances from an existing array.
|
|
*/
|
|
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
|
|
var set = new ArraySet();
|
|
for (var i = 0, len = aArray.length; i < len; i++) {
|
|
set.add(aArray[i], aAllowDuplicates);
|
|
}
|
|
return set;
|
|
};
|
|
|
|
/**
|
|
* Add the given string to this set.
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
|
|
var isDuplicate = this.has(aStr);
|
|
var idx = this._array.length;
|
|
if (!isDuplicate || aAllowDuplicates) {
|
|
this._array.push(aStr);
|
|
}
|
|
if (!isDuplicate) {
|
|
this._set[util.toSetString(aStr)] = idx;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Is the given string a member of this set?
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
ArraySet.prototype.has = function ArraySet_has(aStr) {
|
|
return Object.prototype.hasOwnProperty.call(this._set,
|
|
util.toSetString(aStr));
|
|
};
|
|
|
|
/**
|
|
* What is the index of the given string in the array?
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
|
|
if (this.has(aStr)) {
|
|
return this._set[util.toSetString(aStr)];
|
|
}
|
|
throw new Error('"' + aStr + '" is not in the set.');
|
|
};
|
|
|
|
/**
|
|
* What is the element at the given index?
|
|
*
|
|
* @param Number aIdx
|
|
*/
|
|
ArraySet.prototype.at = function ArraySet_at(aIdx) {
|
|
if (aIdx >= 0 && aIdx < this._array.length) {
|
|
return this._array[aIdx];
|
|
}
|
|
throw new Error('No element indexed by ' + aIdx);
|
|
};
|
|
|
|
/**
|
|
* Returns the array representation of this set (which has the proper indices
|
|
* indicated by indexOf). Note that this is a copy of the internal array used
|
|
* for storing the members so that no one can mess with internal state.
|
|
*/
|
|
ArraySet.prototype.toArray = function ArraySet_toArray() {
|
|
return this._array.slice();
|
|
};
|
|
|
|
exports.ArraySet = ArraySet;
|
|
|
|
});
|
|
|
|
},{"./util":26,"amdefine":5}],19:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*
|
|
* Based on the Base 64 VLQ implementation in Closure Compiler:
|
|
* https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
|
|
*
|
|
* Copyright 2011 The Closure Compiler Authors. All rights reserved.
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of Google Inc. nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var base64 = require('./base64');
|
|
|
|
// A single base 64 digit can contain 6 bits of data. For the base 64 variable
|
|
// length quantities we use in the source map spec, the first bit is the sign,
|
|
// the next four bits are the actual value, and the 6th bit is the
|
|
// continuation bit. The continuation bit tells us whether there are more
|
|
// digits in this value following this digit.
|
|
//
|
|
// Continuation
|
|
// | Sign
|
|
// | |
|
|
// V V
|
|
// 101011
|
|
|
|
var VLQ_BASE_SHIFT = 5;
|
|
|
|
// binary: 100000
|
|
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
|
|
|
|
// binary: 011111
|
|
var VLQ_BASE_MASK = VLQ_BASE - 1;
|
|
|
|
// binary: 100000
|
|
var VLQ_CONTINUATION_BIT = VLQ_BASE;
|
|
|
|
/**
|
|
* Converts from a two-complement value to a value where the sign bit is
|
|
* placed in the least significant bit. For example, as decimals:
|
|
* 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
|
|
* 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
|
|
*/
|
|
function toVLQSigned(aValue) {
|
|
return aValue < 0
|
|
? ((-aValue) << 1) + 1
|
|
: (aValue << 1) + 0;
|
|
}
|
|
|
|
/**
|
|
* Converts to a two-complement value from a value where the sign bit is
|
|
* placed in the least significant bit. For example, as decimals:
|
|
* 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
|
|
* 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
|
|
*/
|
|
function fromVLQSigned(aValue) {
|
|
var isNegative = (aValue & 1) === 1;
|
|
var shifted = aValue >> 1;
|
|
return isNegative
|
|
? -shifted
|
|
: shifted;
|
|
}
|
|
|
|
/**
|
|
* Returns the base 64 VLQ encoded value.
|
|
*/
|
|
exports.encode = function base64VLQ_encode(aValue) {
|
|
var encoded = "";
|
|
var digit;
|
|
|
|
var vlq = toVLQSigned(aValue);
|
|
|
|
do {
|
|
digit = vlq & VLQ_BASE_MASK;
|
|
vlq >>>= VLQ_BASE_SHIFT;
|
|
if (vlq > 0) {
|
|
// There are still more digits in this value, so we must make sure the
|
|
// continuation bit is marked.
|
|
digit |= VLQ_CONTINUATION_BIT;
|
|
}
|
|
encoded += base64.encode(digit);
|
|
} while (vlq > 0);
|
|
|
|
return encoded;
|
|
};
|
|
|
|
/**
|
|
* Decodes the next base 64 VLQ value from the given string and returns the
|
|
* value and the rest of the string via the out parameter.
|
|
*/
|
|
exports.decode = function base64VLQ_decode(aStr, aOutParam) {
|
|
var i = 0;
|
|
var strLen = aStr.length;
|
|
var result = 0;
|
|
var shift = 0;
|
|
var continuation, digit;
|
|
|
|
do {
|
|
if (i >= strLen) {
|
|
throw new Error("Expected more digits in base 64 VLQ value.");
|
|
}
|
|
digit = base64.decode(aStr.charAt(i++));
|
|
continuation = !!(digit & VLQ_CONTINUATION_BIT);
|
|
digit &= VLQ_BASE_MASK;
|
|
result = result + (digit << shift);
|
|
shift += VLQ_BASE_SHIFT;
|
|
} while (continuation);
|
|
|
|
aOutParam.value = fromVLQSigned(result);
|
|
aOutParam.rest = aStr.slice(i);
|
|
};
|
|
|
|
});
|
|
|
|
},{"./base64":20,"amdefine":5}],20:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var charToIntMap = {};
|
|
var intToCharMap = {};
|
|
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
|
.split('')
|
|
.forEach(function (ch, index) {
|
|
charToIntMap[ch] = index;
|
|
intToCharMap[index] = ch;
|
|
});
|
|
|
|
/**
|
|
* Encode an integer in the range of 0 to 63 to a single base 64 digit.
|
|
*/
|
|
exports.encode = function base64_encode(aNumber) {
|
|
if (aNumber in intToCharMap) {
|
|
return intToCharMap[aNumber];
|
|
}
|
|
throw new TypeError("Must be between 0 and 63: " + aNumber);
|
|
};
|
|
|
|
/**
|
|
* Decode a single base 64 digit to an integer.
|
|
*/
|
|
exports.decode = function base64_decode(aChar) {
|
|
if (aChar in charToIntMap) {
|
|
return charToIntMap[aChar];
|
|
}
|
|
throw new TypeError("Not a valid base 64 digit: " + aChar);
|
|
};
|
|
|
|
});
|
|
|
|
},{"amdefine":5}],21:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
/**
|
|
* Recursive implementation of binary search.
|
|
*
|
|
* @param aLow Indices here and lower do not contain the needle.
|
|
* @param aHigh Indices here and higher do not contain the needle.
|
|
* @param aNeedle The element being searched for.
|
|
* @param aHaystack The non-empty array being searched.
|
|
* @param aCompare Function which takes two elements and returns -1, 0, or 1.
|
|
*/
|
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
|
|
// This function terminates when one of the following is true:
|
|
//
|
|
// 1. We find the exact element we are looking for.
|
|
//
|
|
// 2. We did not find the exact element, but we can return the index of
|
|
// the next closest element that is less than that element.
|
|
//
|
|
// 3. We did not find the exact element, and there is no next-closest
|
|
// element which is less than the one we are searching for, so we
|
|
// return -1.
|
|
var mid = Math.floor((aHigh - aLow) / 2) + aLow;
|
|
var cmp = aCompare(aNeedle, aHaystack[mid], true);
|
|
if (cmp === 0) {
|
|
// Found the element we are looking for.
|
|
return mid;
|
|
}
|
|
else if (cmp > 0) {
|
|
// aHaystack[mid] is greater than our needle.
|
|
if (aHigh - mid > 1) {
|
|
// The element is in the upper half.
|
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
|
|
}
|
|
// We did not find an exact match, return the next closest one
|
|
// (termination case 2).
|
|
return mid;
|
|
}
|
|
else {
|
|
// aHaystack[mid] is less than our needle.
|
|
if (mid - aLow > 1) {
|
|
// The element is in the lower half.
|
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
|
|
}
|
|
// The exact needle element was not found in this haystack. Determine if
|
|
// we are in termination case (2) or (3) and return the appropriate thing.
|
|
return aLow < 0 ? -1 : aLow;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is an implementation of binary search which will always try and return
|
|
* the index of next lowest value checked if there is no exact hit. This is
|
|
* because mappings between original and generated line/col pairs are single
|
|
* points, and there is an implicit region between each of them, so a miss
|
|
* just means that you aren't on the very start of a region.
|
|
*
|
|
* @param aNeedle The element you are looking for.
|
|
* @param aHaystack The array that is being searched.
|
|
* @param aCompare A function which takes the needle and an element in the
|
|
* array and returns -1, 0, or 1 depending on whether the needle is less
|
|
* than, equal to, or greater than the element, respectively.
|
|
*/
|
|
exports.search = function search(aNeedle, aHaystack, aCompare) {
|
|
if (aHaystack.length === 0) {
|
|
return -1;
|
|
}
|
|
return recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
|
|
};
|
|
|
|
});
|
|
|
|
},{"amdefine":5}],22:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2014 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var util = require('./util');
|
|
|
|
/**
|
|
* Determine whether mappingB is after mappingA with respect to generated
|
|
* position.
|
|
*/
|
|
function generatedPositionAfter(mappingA, mappingB) {
|
|
// Optimized for most common case
|
|
var lineA = mappingA.generatedLine;
|
|
var lineB = mappingB.generatedLine;
|
|
var columnA = mappingA.generatedColumn;
|
|
var columnB = mappingB.generatedColumn;
|
|
return lineB > lineA || lineB == lineA && columnB >= columnA ||
|
|
util.compareByGeneratedPositions(mappingA, mappingB) <= 0;
|
|
}
|
|
|
|
/**
|
|
* A data structure to provide a sorted view of accumulated mappings in a
|
|
* performance conscious manner. It trades a neglibable overhead in general
|
|
* case for a large speedup in case of mappings being added in order.
|
|
*/
|
|
function MappingList() {
|
|
this._array = [];
|
|
this._sorted = true;
|
|
// Serves as infimum
|
|
this._last = {generatedLine: -1, generatedColumn: 0};
|
|
}
|
|
|
|
/**
|
|
* Iterate through internal items. This method takes the same arguments that
|
|
* `Array.prototype.forEach` takes.
|
|
*
|
|
* NOTE: The order of the mappings is NOT guaranteed.
|
|
*/
|
|
MappingList.prototype.unsortedForEach =
|
|
function MappingList_forEach(aCallback, aThisArg) {
|
|
this._array.forEach(aCallback, aThisArg);
|
|
};
|
|
|
|
/**
|
|
* Add the given source mapping.
|
|
*
|
|
* @param Object aMapping
|
|
*/
|
|
MappingList.prototype.add = function MappingList_add(aMapping) {
|
|
var mapping;
|
|
if (generatedPositionAfter(this._last, aMapping)) {
|
|
this._last = aMapping;
|
|
this._array.push(aMapping);
|
|
} else {
|
|
this._sorted = false;
|
|
this._array.push(aMapping);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the flat, sorted array of mappings. The mappings are sorted by
|
|
* generated position.
|
|
*
|
|
* WARNING: This method returns internal data without copying, for
|
|
* performance. The return value must NOT be mutated, and should be treated as
|
|
* an immutable borrow. If you want to take ownership, you must make your own
|
|
* copy.
|
|
*/
|
|
MappingList.prototype.toArray = function MappingList_toArray() {
|
|
if (!this._sorted) {
|
|
this._array.sort(util.compareByGeneratedPositions);
|
|
this._sorted = true;
|
|
}
|
|
return this._array;
|
|
};
|
|
|
|
exports.MappingList = MappingList;
|
|
|
|
});
|
|
|
|
},{"./util":26,"amdefine":5}],23:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var util = require('./util');
|
|
var binarySearch = require('./binary-search');
|
|
var ArraySet = require('./array-set').ArraySet;
|
|
var base64VLQ = require('./base64-vlq');
|
|
|
|
/**
|
|
* A SourceMapConsumer instance represents a parsed source map which we can
|
|
* query for information about the original file positions by giving it a file
|
|
* position in the generated source.
|
|
*
|
|
* The only parameter is the raw source map (either as a JSON string, or
|
|
* already parsed to an object). According to the spec, source maps have the
|
|
* following attributes:
|
|
*
|
|
* - version: Which version of the source map spec this map is following.
|
|
* - sources: An array of URLs to the original source files.
|
|
* - names: An array of identifiers which can be referrenced by individual mappings.
|
|
* - sourceRoot: Optional. The URL root from which all sources are relative.
|
|
* - sourcesContent: Optional. An array of contents of the original source files.
|
|
* - mappings: A string of base64 VLQs which contain the actual mappings.
|
|
* - file: Optional. The generated file this source map is associated with.
|
|
*
|
|
* Here is an example source map, taken from the source map spec[0]:
|
|
*
|
|
* {
|
|
* version : 3,
|
|
* file: "out.js",
|
|
* sourceRoot : "",
|
|
* sources: ["foo.js", "bar.js"],
|
|
* names: ["src", "maps", "are", "fun"],
|
|
* mappings: "AA,AB;;ABCDE;"
|
|
* }
|
|
*
|
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
|
|
*/
|
|
function SourceMapConsumer(aSourceMap) {
|
|
var sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === 'string') {
|
|
sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
|
|
}
|
|
|
|
var version = util.getArg(sourceMap, 'version');
|
|
var sources = util.getArg(sourceMap, 'sources');
|
|
// Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
|
|
// requires the array) to play nice here.
|
|
var names = util.getArg(sourceMap, 'names', []);
|
|
var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
|
|
var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
|
|
var mappings = util.getArg(sourceMap, 'mappings');
|
|
var file = util.getArg(sourceMap, 'file', null);
|
|
|
|
// Once again, Sass deviates from the spec and supplies the version as a
|
|
// string rather than a number, so we use loose equality checking here.
|
|
if (version != this._version) {
|
|
throw new Error('Unsupported version: ' + version);
|
|
}
|
|
|
|
// Some source maps produce relative source paths like "./foo.js" instead of
|
|
// "foo.js". Normalize these first so that future comparisons will succeed.
|
|
// See bugzil.la/1090768.
|
|
sources = sources.map(util.normalize);
|
|
|
|
// Pass `true` below to allow duplicate names and sources. While source maps
|
|
// are intended to be compressed and deduplicated, the TypeScript compiler
|
|
// sometimes generates source maps with duplicates in them. See Github issue
|
|
// #72 and bugzil.la/889492.
|
|
this._names = ArraySet.fromArray(names, true);
|
|
this._sources = ArraySet.fromArray(sources, true);
|
|
|
|
this.sourceRoot = sourceRoot;
|
|
this.sourcesContent = sourcesContent;
|
|
this._mappings = mappings;
|
|
this.file = file;
|
|
}
|
|
|
|
/**
|
|
* Create a SourceMapConsumer from a SourceMapGenerator.
|
|
*
|
|
* @param SourceMapGenerator aSourceMap
|
|
* The source map that will be consumed.
|
|
* @returns SourceMapConsumer
|
|
*/
|
|
SourceMapConsumer.fromSourceMap =
|
|
function SourceMapConsumer_fromSourceMap(aSourceMap) {
|
|
var smc = Object.create(SourceMapConsumer.prototype);
|
|
|
|
smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
|
|
smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
|
|
smc.sourceRoot = aSourceMap._sourceRoot;
|
|
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
|
|
smc.sourceRoot);
|
|
smc.file = aSourceMap._file;
|
|
|
|
smc.__generatedMappings = aSourceMap._mappings.toArray().slice();
|
|
smc.__originalMappings = aSourceMap._mappings.toArray().slice()
|
|
.sort(util.compareByOriginalPositions);
|
|
|
|
return smc;
|
|
};
|
|
|
|
/**
|
|
* The version of the source mapping spec that we are consuming.
|
|
*/
|
|
SourceMapConsumer.prototype._version = 3;
|
|
|
|
/**
|
|
* The list of original sources.
|
|
*/
|
|
Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
|
|
get: function () {
|
|
return this._sources.toArray().map(function (s) {
|
|
return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
|
|
}, this);
|
|
}
|
|
});
|
|
|
|
// `__generatedMappings` and `__originalMappings` are arrays that hold the
|
|
// parsed mapping coordinates from the source map's "mappings" attribute. They
|
|
// are lazily instantiated, accessed via the `_generatedMappings` and
|
|
// `_originalMappings` getters respectively, and we only parse the mappings
|
|
// and create these arrays once queried for a source location. We jump through
|
|
// these hoops because there can be many thousands of mappings, and parsing
|
|
// them is expensive, so we only want to do it if we must.
|
|
//
|
|
// Each object in the arrays is of the form:
|
|
//
|
|
// {
|
|
// generatedLine: The line number in the generated code,
|
|
// generatedColumn: The column number in the generated code,
|
|
// source: The path to the original source file that generated this
|
|
// chunk of code,
|
|
// originalLine: The line number in the original source that
|
|
// corresponds to this chunk of generated code,
|
|
// originalColumn: The column number in the original source that
|
|
// corresponds to this chunk of generated code,
|
|
// name: The name of the original symbol which generated this chunk of
|
|
// code.
|
|
// }
|
|
//
|
|
// All properties except for `generatedLine` and `generatedColumn` can be
|
|
// `null`.
|
|
//
|
|
// `_generatedMappings` is ordered by the generated positions.
|
|
//
|
|
// `_originalMappings` is ordered by the original positions.
|
|
|
|
SourceMapConsumer.prototype.__generatedMappings = null;
|
|
Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
|
|
get: function () {
|
|
if (!this.__generatedMappings) {
|
|
this.__generatedMappings = [];
|
|
this.__originalMappings = [];
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
}
|
|
|
|
return this.__generatedMappings;
|
|
}
|
|
});
|
|
|
|
SourceMapConsumer.prototype.__originalMappings = null;
|
|
Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
|
|
get: function () {
|
|
if (!this.__originalMappings) {
|
|
this.__generatedMappings = [];
|
|
this.__originalMappings = [];
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
}
|
|
|
|
return this.__originalMappings;
|
|
}
|
|
});
|
|
|
|
SourceMapConsumer.prototype._nextCharIsMappingSeparator =
|
|
function SourceMapConsumer_nextCharIsMappingSeparator(aStr) {
|
|
var c = aStr.charAt(0);
|
|
return c === ";" || c === ",";
|
|
};
|
|
|
|
/**
|
|
* Parse the mappings in a string in to a data structure which we can easily
|
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
|
* `this.__originalMappings` properties).
|
|
*/
|
|
SourceMapConsumer.prototype._parseMappings =
|
|
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
|
var generatedLine = 1;
|
|
var previousGeneratedColumn = 0;
|
|
var previousOriginalLine = 0;
|
|
var previousOriginalColumn = 0;
|
|
var previousSource = 0;
|
|
var previousName = 0;
|
|
var str = aStr;
|
|
var temp = {};
|
|
var mapping;
|
|
|
|
while (str.length > 0) {
|
|
if (str.charAt(0) === ';') {
|
|
generatedLine++;
|
|
str = str.slice(1);
|
|
previousGeneratedColumn = 0;
|
|
}
|
|
else if (str.charAt(0) === ',') {
|
|
str = str.slice(1);
|
|
}
|
|
else {
|
|
mapping = {};
|
|
mapping.generatedLine = generatedLine;
|
|
|
|
// Generated column.
|
|
base64VLQ.decode(str, temp);
|
|
mapping.generatedColumn = previousGeneratedColumn + temp.value;
|
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
str = temp.rest;
|
|
|
|
if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
|
|
// Original source.
|
|
base64VLQ.decode(str, temp);
|
|
mapping.source = this._sources.at(previousSource + temp.value);
|
|
previousSource += temp.value;
|
|
str = temp.rest;
|
|
if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
|
|
throw new Error('Found a source, but no line and column');
|
|
}
|
|
|
|
// Original line.
|
|
base64VLQ.decode(str, temp);
|
|
mapping.originalLine = previousOriginalLine + temp.value;
|
|
previousOriginalLine = mapping.originalLine;
|
|
// Lines are stored 0-based
|
|
mapping.originalLine += 1;
|
|
str = temp.rest;
|
|
if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
|
|
throw new Error('Found a source and line, but no column');
|
|
}
|
|
|
|
// Original column.
|
|
base64VLQ.decode(str, temp);
|
|
mapping.originalColumn = previousOriginalColumn + temp.value;
|
|
previousOriginalColumn = mapping.originalColumn;
|
|
str = temp.rest;
|
|
|
|
if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
|
|
// Original name.
|
|
base64VLQ.decode(str, temp);
|
|
mapping.name = this._names.at(previousName + temp.value);
|
|
previousName += temp.value;
|
|
str = temp.rest;
|
|
}
|
|
}
|
|
|
|
this.__generatedMappings.push(mapping);
|
|
if (typeof mapping.originalLine === 'number') {
|
|
this.__originalMappings.push(mapping);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.__generatedMappings.sort(util.compareByGeneratedPositions);
|
|
this.__originalMappings.sort(util.compareByOriginalPositions);
|
|
};
|
|
|
|
/**
|
|
* Find the mapping that best matches the hypothetical "needle" mapping that
|
|
* we are searching for in the given "haystack" of mappings.
|
|
*/
|
|
SourceMapConsumer.prototype._findMapping =
|
|
function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
|
|
aColumnName, aComparator) {
|
|
// To return the position we are searching for, we must first find the
|
|
// mapping for the given position and then return the opposite position it
|
|
// points to. Because the mappings are sorted, we can use binary search to
|
|
// find the best mapping.
|
|
|
|
if (aNeedle[aLineName] <= 0) {
|
|
throw new TypeError('Line must be greater than or equal to 1, got '
|
|
+ aNeedle[aLineName]);
|
|
}
|
|
if (aNeedle[aColumnName] < 0) {
|
|
throw new TypeError('Column must be greater than or equal to 0, got '
|
|
+ aNeedle[aColumnName]);
|
|
}
|
|
|
|
return binarySearch.search(aNeedle, aMappings, aComparator);
|
|
};
|
|
|
|
/**
|
|
* Compute the last column for each generated mapping. The last column is
|
|
* inclusive.
|
|
*/
|
|
SourceMapConsumer.prototype.computeColumnSpans =
|
|
function SourceMapConsumer_computeColumnSpans() {
|
|
for (var index = 0; index < this._generatedMappings.length; ++index) {
|
|
var mapping = this._generatedMappings[index];
|
|
|
|
// Mappings do not contain a field for the last generated columnt. We
|
|
// can come up with an optimistic estimate, however, by assuming that
|
|
// mappings are contiguous (i.e. given two consecutive mappings, the
|
|
// first mapping ends where the second one starts).
|
|
if (index + 1 < this._generatedMappings.length) {
|
|
var nextMapping = this._generatedMappings[index + 1];
|
|
|
|
if (mapping.generatedLine === nextMapping.generatedLine) {
|
|
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// The last mapping for each line spans the entire line.
|
|
mapping.lastGeneratedColumn = Infinity;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the original source, line, and column information for the generated
|
|
* source's line and column positions provided. The only argument is an object
|
|
* with the following properties:
|
|
*
|
|
* - line: The line number in the generated source.
|
|
* - column: The column number in the generated source.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - source: The original source file, or null.
|
|
* - line: The line number in the original source, or null.
|
|
* - column: The column number in the original source, or null.
|
|
* - name: The original identifier, or null.
|
|
*/
|
|
SourceMapConsumer.prototype.originalPositionFor =
|
|
function SourceMapConsumer_originalPositionFor(aArgs) {
|
|
var needle = {
|
|
generatedLine: util.getArg(aArgs, 'line'),
|
|
generatedColumn: util.getArg(aArgs, 'column')
|
|
};
|
|
|
|
var index = this._findMapping(needle,
|
|
this._generatedMappings,
|
|
"generatedLine",
|
|
"generatedColumn",
|
|
util.compareByGeneratedPositions);
|
|
|
|
if (index >= 0) {
|
|
var mapping = this._generatedMappings[index];
|
|
|
|
if (mapping.generatedLine === needle.generatedLine) {
|
|
var source = util.getArg(mapping, 'source', null);
|
|
if (source != null && this.sourceRoot != null) {
|
|
source = util.join(this.sourceRoot, source);
|
|
}
|
|
return {
|
|
source: source,
|
|
line: util.getArg(mapping, 'originalLine', null),
|
|
column: util.getArg(mapping, 'originalColumn', null),
|
|
name: util.getArg(mapping, 'name', null)
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
source: null,
|
|
line: null,
|
|
column: null,
|
|
name: null
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Returns the original source content. The only argument is the url of the
|
|
* original source file. Returns null if no original source content is
|
|
* availible.
|
|
*/
|
|
SourceMapConsumer.prototype.sourceContentFor =
|
|
function SourceMapConsumer_sourceContentFor(aSource) {
|
|
if (!this.sourcesContent) {
|
|
return null;
|
|
}
|
|
|
|
if (this.sourceRoot != null) {
|
|
aSource = util.relative(this.sourceRoot, aSource);
|
|
}
|
|
|
|
if (this._sources.has(aSource)) {
|
|
return this.sourcesContent[this._sources.indexOf(aSource)];
|
|
}
|
|
|
|
var url;
|
|
if (this.sourceRoot != null
|
|
&& (url = util.urlParse(this.sourceRoot))) {
|
|
// XXX: file:// URIs and absolute paths lead to unexpected behavior for
|
|
// many users. We can help them out when they expect file:// URIs to
|
|
// behave like it would if they were running a local HTTP server. See
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
|
|
var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
|
|
if (url.scheme == "file"
|
|
&& this._sources.has(fileUriAbsPath)) {
|
|
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
|
|
}
|
|
|
|
if ((!url.path || url.path == "/")
|
|
&& this._sources.has("/" + aSource)) {
|
|
return this.sourcesContent[this._sources.indexOf("/" + aSource)];
|
|
}
|
|
}
|
|
|
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
|
};
|
|
|
|
/**
|
|
* Returns the generated line and column information for the original source,
|
|
* line, and column positions provided. The only argument is an object with
|
|
* the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source.
|
|
* - column: The column number in the original source.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null.
|
|
* - column: The column number in the generated source, or null.
|
|
*/
|
|
SourceMapConsumer.prototype.generatedPositionFor =
|
|
function SourceMapConsumer_generatedPositionFor(aArgs) {
|
|
var needle = {
|
|
source: util.getArg(aArgs, 'source'),
|
|
originalLine: util.getArg(aArgs, 'line'),
|
|
originalColumn: util.getArg(aArgs, 'column')
|
|
};
|
|
|
|
if (this.sourceRoot != null) {
|
|
needle.source = util.relative(this.sourceRoot, needle.source);
|
|
}
|
|
|
|
var index = this._findMapping(needle,
|
|
this._originalMappings,
|
|
"originalLine",
|
|
"originalColumn",
|
|
util.compareByOriginalPositions);
|
|
|
|
if (index >= 0) {
|
|
var mapping = this._originalMappings[index];
|
|
|
|
return {
|
|
line: util.getArg(mapping, 'generatedLine', null),
|
|
column: util.getArg(mapping, 'generatedColumn', null),
|
|
lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
|
|
};
|
|
}
|
|
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Returns all generated line and column information for the original source
|
|
* and line provided. The only argument is an object with the following
|
|
* properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source.
|
|
*
|
|
* and an array of objects is returned, each with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null.
|
|
* - column: The column number in the generated source, or null.
|
|
*/
|
|
SourceMapConsumer.prototype.allGeneratedPositionsFor =
|
|
function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
|
|
// When there is no exact match, SourceMapConsumer.prototype._findMapping
|
|
// returns the index of the closest mapping less than the needle. By
|
|
// setting needle.originalColumn to Infinity, we thus find the last
|
|
// mapping for the given line, provided such a mapping exists.
|
|
var needle = {
|
|
source: util.getArg(aArgs, 'source'),
|
|
originalLine: util.getArg(aArgs, 'line'),
|
|
originalColumn: Infinity
|
|
};
|
|
|
|
if (this.sourceRoot != null) {
|
|
needle.source = util.relative(this.sourceRoot, needle.source);
|
|
}
|
|
|
|
var mappings = [];
|
|
|
|
var index = this._findMapping(needle,
|
|
this._originalMappings,
|
|
"originalLine",
|
|
"originalColumn",
|
|
util.compareByOriginalPositions);
|
|
if (index >= 0) {
|
|
var mapping = this._originalMappings[index];
|
|
|
|
while (mapping && mapping.originalLine === needle.originalLine) {
|
|
mappings.push({
|
|
line: util.getArg(mapping, 'generatedLine', null),
|
|
column: util.getArg(mapping, 'generatedColumn', null),
|
|
lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
|
|
});
|
|
|
|
mapping = this._originalMappings[--index];
|
|
}
|
|
}
|
|
|
|
return mappings.reverse();
|
|
};
|
|
|
|
SourceMapConsumer.GENERATED_ORDER = 1;
|
|
SourceMapConsumer.ORIGINAL_ORDER = 2;
|
|
|
|
/**
|
|
* Iterate over each mapping between an original source/line/column and a
|
|
* generated line/column in this source map.
|
|
*
|
|
* @param Function aCallback
|
|
* The function that is called with each mapping.
|
|
* @param Object aContext
|
|
* Optional. If specified, this object will be the value of `this` every
|
|
* time that `aCallback` is called.
|
|
* @param aOrder
|
|
* Either `SourceMapConsumer.GENERATED_ORDER` or
|
|
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
|
|
* iterate over the mappings sorted by the generated file's line/column
|
|
* order or the original's source/line/column order, respectively. Defaults to
|
|
* `SourceMapConsumer.GENERATED_ORDER`.
|
|
*/
|
|
SourceMapConsumer.prototype.eachMapping =
|
|
function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
|
|
var context = aContext || null;
|
|
var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
|
|
|
|
var mappings;
|
|
switch (order) {
|
|
case SourceMapConsumer.GENERATED_ORDER:
|
|
mappings = this._generatedMappings;
|
|
break;
|
|
case SourceMapConsumer.ORIGINAL_ORDER:
|
|
mappings = this._originalMappings;
|
|
break;
|
|
default:
|
|
throw new Error("Unknown order of iteration.");
|
|
}
|
|
|
|
var sourceRoot = this.sourceRoot;
|
|
mappings.map(function (mapping) {
|
|
var source = mapping.source;
|
|
if (source != null && sourceRoot != null) {
|
|
source = util.join(sourceRoot, source);
|
|
}
|
|
return {
|
|
source: source,
|
|
generatedLine: mapping.generatedLine,
|
|
generatedColumn: mapping.generatedColumn,
|
|
originalLine: mapping.originalLine,
|
|
originalColumn: mapping.originalColumn,
|
|
name: mapping.name
|
|
};
|
|
}).forEach(aCallback, context);
|
|
};
|
|
|
|
exports.SourceMapConsumer = SourceMapConsumer;
|
|
|
|
});
|
|
|
|
},{"./array-set":18,"./base64-vlq":19,"./binary-search":21,"./util":26,"amdefine":5}],24:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var base64VLQ = require('./base64-vlq');
|
|
var util = require('./util');
|
|
var ArraySet = require('./array-set').ArraySet;
|
|
var MappingList = require('./mapping-list').MappingList;
|
|
|
|
/**
|
|
* An instance of the SourceMapGenerator represents a source map which is
|
|
* being built incrementally. You may pass an object with the following
|
|
* properties:
|
|
*
|
|
* - file: The filename of the generated source.
|
|
* - sourceRoot: A root for all relative URLs in this source map.
|
|
*/
|
|
function SourceMapGenerator(aArgs) {
|
|
if (!aArgs) {
|
|
aArgs = {};
|
|
}
|
|
this._file = util.getArg(aArgs, 'file', null);
|
|
this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
|
|
this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
|
|
this._sources = new ArraySet();
|
|
this._names = new ArraySet();
|
|
this._mappings = new MappingList();
|
|
this._sourcesContents = null;
|
|
}
|
|
|
|
SourceMapGenerator.prototype._version = 3;
|
|
|
|
/**
|
|
* Creates a new SourceMapGenerator based on a SourceMapConsumer
|
|
*
|
|
* @param aSourceMapConsumer The SourceMap.
|
|
*/
|
|
SourceMapGenerator.fromSourceMap =
|
|
function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
|
|
var sourceRoot = aSourceMapConsumer.sourceRoot;
|
|
var generator = new SourceMapGenerator({
|
|
file: aSourceMapConsumer.file,
|
|
sourceRoot: sourceRoot
|
|
});
|
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
|
var newMapping = {
|
|
generated: {
|
|
line: mapping.generatedLine,
|
|
column: mapping.generatedColumn
|
|
}
|
|
};
|
|
|
|
if (mapping.source != null) {
|
|
newMapping.source = mapping.source;
|
|
if (sourceRoot != null) {
|
|
newMapping.source = util.relative(sourceRoot, newMapping.source);
|
|
}
|
|
|
|
newMapping.original = {
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
};
|
|
|
|
if (mapping.name != null) {
|
|
newMapping.name = mapping.name;
|
|
}
|
|
}
|
|
|
|
generator.addMapping(newMapping);
|
|
});
|
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
generator.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
return generator;
|
|
};
|
|
|
|
/**
|
|
* Add a single mapping from original source line and column to the generated
|
|
* source's line and column for this source map being created. The mapping
|
|
* object should have the following properties:
|
|
*
|
|
* - generated: An object with the generated line and column positions.
|
|
* - original: An object with the original line and column positions.
|
|
* - source: The original source file (relative to the sourceRoot).
|
|
* - name: An optional original token name for this mapping.
|
|
*/
|
|
SourceMapGenerator.prototype.addMapping =
|
|
function SourceMapGenerator_addMapping(aArgs) {
|
|
var generated = util.getArg(aArgs, 'generated');
|
|
var original = util.getArg(aArgs, 'original', null);
|
|
var source = util.getArg(aArgs, 'source', null);
|
|
var name = util.getArg(aArgs, 'name', null);
|
|
|
|
if (!this._skipValidation) {
|
|
this._validateMapping(generated, original, source, name);
|
|
}
|
|
|
|
if (source != null && !this._sources.has(source)) {
|
|
this._sources.add(source);
|
|
}
|
|
|
|
if (name != null && !this._names.has(name)) {
|
|
this._names.add(name);
|
|
}
|
|
|
|
this._mappings.add({
|
|
generatedLine: generated.line,
|
|
generatedColumn: generated.column,
|
|
originalLine: original != null && original.line,
|
|
originalColumn: original != null && original.column,
|
|
source: source,
|
|
name: name
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Set the source content for a source file.
|
|
*/
|
|
SourceMapGenerator.prototype.setSourceContent =
|
|
function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
|
|
var source = aSourceFile;
|
|
if (this._sourceRoot != null) {
|
|
source = util.relative(this._sourceRoot, source);
|
|
}
|
|
|
|
if (aSourceContent != null) {
|
|
// Add the source content to the _sourcesContents map.
|
|
// Create a new _sourcesContents map if the property is null.
|
|
if (!this._sourcesContents) {
|
|
this._sourcesContents = {};
|
|
}
|
|
this._sourcesContents[util.toSetString(source)] = aSourceContent;
|
|
} else if (this._sourcesContents) {
|
|
// Remove the source file from the _sourcesContents map.
|
|
// If the _sourcesContents map is empty, set the property to null.
|
|
delete this._sourcesContents[util.toSetString(source)];
|
|
if (Object.keys(this._sourcesContents).length === 0) {
|
|
this._sourcesContents = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Applies the mappings of a sub-source-map for a specific source file to the
|
|
* source map being generated. Each mapping to the supplied source file is
|
|
* rewritten using the supplied source map. Note: The resolution for the
|
|
* resulting mappings is the minimium of this map and the supplied map.
|
|
*
|
|
* @param aSourceMapConsumer The source map to be applied.
|
|
* @param aSourceFile Optional. The filename of the source file.
|
|
* If omitted, SourceMapConsumer's file property will be used.
|
|
* @param aSourceMapPath Optional. The dirname of the path to the source map
|
|
* to be applied. If relative, it is relative to the SourceMapConsumer.
|
|
* This parameter is needed when the two source maps aren't in the same
|
|
* directory, and the source map to be applied contains relative source
|
|
* paths. If so, those relative source paths need to be rewritten
|
|
* relative to the SourceMapGenerator.
|
|
*/
|
|
SourceMapGenerator.prototype.applySourceMap =
|
|
function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
|
|
var sourceFile = aSourceFile;
|
|
// If aSourceFile is omitted, we will use the file property of the SourceMap
|
|
if (aSourceFile == null) {
|
|
if (aSourceMapConsumer.file == null) {
|
|
throw new Error(
|
|
'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
|
|
'or the source map\'s "file" property. Both were omitted.'
|
|
);
|
|
}
|
|
sourceFile = aSourceMapConsumer.file;
|
|
}
|
|
var sourceRoot = this._sourceRoot;
|
|
// Make "sourceFile" relative if an absolute Url is passed.
|
|
if (sourceRoot != null) {
|
|
sourceFile = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
// Applying the SourceMap can add and remove items from the sources and
|
|
// the names array.
|
|
var newSources = new ArraySet();
|
|
var newNames = new ArraySet();
|
|
|
|
// Find mappings for the "sourceFile"
|
|
this._mappings.unsortedForEach(function (mapping) {
|
|
if (mapping.source === sourceFile && mapping.originalLine != null) {
|
|
// Check if it can be mapped by the source map, then update the mapping.
|
|
var original = aSourceMapConsumer.originalPositionFor({
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
});
|
|
if (original.source != null) {
|
|
// Copy mapping
|
|
mapping.source = original.source;
|
|
if (aSourceMapPath != null) {
|
|
mapping.source = util.join(aSourceMapPath, mapping.source)
|
|
}
|
|
if (sourceRoot != null) {
|
|
mapping.source = util.relative(sourceRoot, mapping.source);
|
|
}
|
|
mapping.originalLine = original.line;
|
|
mapping.originalColumn = original.column;
|
|
if (original.name != null) {
|
|
mapping.name = original.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
var source = mapping.source;
|
|
if (source != null && !newSources.has(source)) {
|
|
newSources.add(source);
|
|
}
|
|
|
|
var name = mapping.name;
|
|
if (name != null && !newNames.has(name)) {
|
|
newNames.add(name);
|
|
}
|
|
|
|
}, this);
|
|
this._sources = newSources;
|
|
this._names = newNames;
|
|
|
|
// Copy sourcesContents of applied map.
|
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
if (aSourceMapPath != null) {
|
|
sourceFile = util.join(aSourceMapPath, sourceFile);
|
|
}
|
|
if (sourceRoot != null) {
|
|
sourceFile = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
this.setSourceContent(sourceFile, content);
|
|
}
|
|
}, this);
|
|
};
|
|
|
|
/**
|
|
* A mapping can have one of the three levels of data:
|
|
*
|
|
* 1. Just the generated position.
|
|
* 2. The Generated position, original position, and original source.
|
|
* 3. Generated and original position, original source, as well as a name
|
|
* token.
|
|
*
|
|
* To maintain consistency, we validate that any new mapping being added falls
|
|
* in to one of these categories.
|
|
*/
|
|
SourceMapGenerator.prototype._validateMapping =
|
|
function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
|
|
aName) {
|
|
if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
|
&& !aOriginal && !aSource && !aName) {
|
|
// Case 1.
|
|
return;
|
|
}
|
|
else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
|
&& aOriginal && 'line' in aOriginal && 'column' in aOriginal
|
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
|
&& aOriginal.line > 0 && aOriginal.column >= 0
|
|
&& aSource) {
|
|
// Cases 2 and 3.
|
|
return;
|
|
}
|
|
else {
|
|
throw new Error('Invalid mapping: ' + JSON.stringify({
|
|
generated: aGenerated,
|
|
source: aSource,
|
|
original: aOriginal,
|
|
name: aName
|
|
}));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Serialize the accumulated mappings in to the stream of base 64 VLQs
|
|
* specified by the source map format.
|
|
*/
|
|
SourceMapGenerator.prototype._serializeMappings =
|
|
function SourceMapGenerator_serializeMappings() {
|
|
var previousGeneratedColumn = 0;
|
|
var previousGeneratedLine = 1;
|
|
var previousOriginalColumn = 0;
|
|
var previousOriginalLine = 0;
|
|
var previousName = 0;
|
|
var previousSource = 0;
|
|
var result = '';
|
|
var mapping;
|
|
|
|
var mappings = this._mappings.toArray();
|
|
|
|
for (var i = 0, len = mappings.length; i < len; i++) {
|
|
mapping = mappings[i];
|
|
|
|
if (mapping.generatedLine !== previousGeneratedLine) {
|
|
previousGeneratedColumn = 0;
|
|
while (mapping.generatedLine !== previousGeneratedLine) {
|
|
result += ';';
|
|
previousGeneratedLine++;
|
|
}
|
|
}
|
|
else {
|
|
if (i > 0) {
|
|
if (!util.compareByGeneratedPositions(mapping, mappings[i - 1])) {
|
|
continue;
|
|
}
|
|
result += ',';
|
|
}
|
|
}
|
|
|
|
result += base64VLQ.encode(mapping.generatedColumn
|
|
- previousGeneratedColumn);
|
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
|
|
if (mapping.source != null) {
|
|
result += base64VLQ.encode(this._sources.indexOf(mapping.source)
|
|
- previousSource);
|
|
previousSource = this._sources.indexOf(mapping.source);
|
|
|
|
// lines are stored 0-based in SourceMap spec version 3
|
|
result += base64VLQ.encode(mapping.originalLine - 1
|
|
- previousOriginalLine);
|
|
previousOriginalLine = mapping.originalLine - 1;
|
|
|
|
result += base64VLQ.encode(mapping.originalColumn
|
|
- previousOriginalColumn);
|
|
previousOriginalColumn = mapping.originalColumn;
|
|
|
|
if (mapping.name != null) {
|
|
result += base64VLQ.encode(this._names.indexOf(mapping.name)
|
|
- previousName);
|
|
previousName = this._names.indexOf(mapping.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
SourceMapGenerator.prototype._generateSourcesContent =
|
|
function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
|
|
return aSources.map(function (source) {
|
|
if (!this._sourcesContents) {
|
|
return null;
|
|
}
|
|
if (aSourceRoot != null) {
|
|
source = util.relative(aSourceRoot, source);
|
|
}
|
|
var key = util.toSetString(source);
|
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents,
|
|
key)
|
|
? this._sourcesContents[key]
|
|
: null;
|
|
}, this);
|
|
};
|
|
|
|
/**
|
|
* Externalize the source map.
|
|
*/
|
|
SourceMapGenerator.prototype.toJSON =
|
|
function SourceMapGenerator_toJSON() {
|
|
var map = {
|
|
version: this._version,
|
|
sources: this._sources.toArray(),
|
|
names: this._names.toArray(),
|
|
mappings: this._serializeMappings()
|
|
};
|
|
if (this._file != null) {
|
|
map.file = this._file;
|
|
}
|
|
if (this._sourceRoot != null) {
|
|
map.sourceRoot = this._sourceRoot;
|
|
}
|
|
if (this._sourcesContents) {
|
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
|
|
}
|
|
|
|
return map;
|
|
};
|
|
|
|
/**
|
|
* Render the source map being generated to a string.
|
|
*/
|
|
SourceMapGenerator.prototype.toString =
|
|
function SourceMapGenerator_toString() {
|
|
return JSON.stringify(this);
|
|
};
|
|
|
|
exports.SourceMapGenerator = SourceMapGenerator;
|
|
|
|
});
|
|
|
|
},{"./array-set":18,"./base64-vlq":19,"./mapping-list":22,"./util":26,"amdefine":5}],25:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
|
|
var util = require('./util');
|
|
|
|
// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
|
|
// operating systems these days (capturing the result).
|
|
var REGEX_NEWLINE = /(\r?\n)/;
|
|
|
|
// Newline character code for charCodeAt() comparisons
|
|
var NEWLINE_CODE = 10;
|
|
|
|
// Private symbol for identifying `SourceNode`s when multiple versions of
|
|
// the source-map library are loaded. This MUST NOT CHANGE across
|
|
// versions!
|
|
var isSourceNode = "$$$isSourceNode$$$";
|
|
|
|
/**
|
|
* SourceNodes provide a way to abstract over interpolating/concatenating
|
|
* snippets of generated JavaScript source code while maintaining the line and
|
|
* column information associated with the original source code.
|
|
*
|
|
* @param aLine The original line number.
|
|
* @param aColumn The original column number.
|
|
* @param aSource The original source's filename.
|
|
* @param aChunks Optional. An array of strings which are snippets of
|
|
* generated JS, or other SourceNodes.
|
|
* @param aName The original identifier.
|
|
*/
|
|
function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
|
|
this.children = [];
|
|
this.sourceContents = {};
|
|
this.line = aLine == null ? null : aLine;
|
|
this.column = aColumn == null ? null : aColumn;
|
|
this.source = aSource == null ? null : aSource;
|
|
this.name = aName == null ? null : aName;
|
|
this[isSourceNode] = true;
|
|
if (aChunks != null) this.add(aChunks);
|
|
}
|
|
|
|
/**
|
|
* Creates a SourceNode from generated code and a SourceMapConsumer.
|
|
*
|
|
* @param aGeneratedCode The generated code
|
|
* @param aSourceMapConsumer The SourceMap for the generated code
|
|
* @param aRelativePath Optional. The path that relative sources in the
|
|
* SourceMapConsumer should be relative to.
|
|
*/
|
|
SourceNode.fromStringWithSourceMap =
|
|
function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
|
|
// The SourceNode we want to fill with the generated code
|
|
// and the SourceMap
|
|
var node = new SourceNode();
|
|
|
|
// All even indices of this array are one line of the generated code,
|
|
// while all odd indices are the newlines between two adjacent lines
|
|
// (since `REGEX_NEWLINE` captures its match).
|
|
// Processed fragments are removed from this array, by calling `shiftNextLine`.
|
|
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
|
|
var shiftNextLine = function() {
|
|
var lineContents = remainingLines.shift();
|
|
// The last line of a file might not have a newline.
|
|
var newLine = remainingLines.shift() || "";
|
|
return lineContents + newLine;
|
|
};
|
|
|
|
// We need to remember the position of "remainingLines"
|
|
var lastGeneratedLine = 1, lastGeneratedColumn = 0;
|
|
|
|
// The generate SourceNodes we need a code range.
|
|
// To extract it current and last mapping is used.
|
|
// Here we store the last mapping.
|
|
var lastMapping = null;
|
|
|
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
|
if (lastMapping !== null) {
|
|
// We add the code from "lastMapping" to "mapping":
|
|
// First check if there is a new line in between.
|
|
if (lastGeneratedLine < mapping.generatedLine) {
|
|
var code = "";
|
|
// Associate first line with "lastMapping"
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
lastGeneratedLine++;
|
|
lastGeneratedColumn = 0;
|
|
// The remaining code is added without mapping
|
|
} else {
|
|
// There is no new line in between.
|
|
// Associate the code between "lastGeneratedColumn" and
|
|
// "mapping.generatedColumn" with "lastMapping"
|
|
var nextLine = remainingLines[0];
|
|
var code = nextLine.substr(0, mapping.generatedColumn -
|
|
lastGeneratedColumn);
|
|
remainingLines[0] = nextLine.substr(mapping.generatedColumn -
|
|
lastGeneratedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
addMappingWithCode(lastMapping, code);
|
|
// No more remaining code, continue
|
|
lastMapping = mapping;
|
|
return;
|
|
}
|
|
}
|
|
// We add the generated code until the first mapping
|
|
// to the SourceNode without any mapping.
|
|
// Each line is added as separate string.
|
|
while (lastGeneratedLine < mapping.generatedLine) {
|
|
node.add(shiftNextLine());
|
|
lastGeneratedLine++;
|
|
}
|
|
if (lastGeneratedColumn < mapping.generatedColumn) {
|
|
var nextLine = remainingLines[0];
|
|
node.add(nextLine.substr(0, mapping.generatedColumn));
|
|
remainingLines[0] = nextLine.substr(mapping.generatedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
}
|
|
lastMapping = mapping;
|
|
}, this);
|
|
// We have processed all mappings.
|
|
if (remainingLines.length > 0) {
|
|
if (lastMapping) {
|
|
// Associate the remaining code in the current line with "lastMapping"
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
}
|
|
// and add the remaining lines without any mapping
|
|
node.add(remainingLines.join(""));
|
|
}
|
|
|
|
// Copy sourcesContent into SourceNode
|
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
if (aRelativePath != null) {
|
|
sourceFile = util.join(aRelativePath, sourceFile);
|
|
}
|
|
node.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
|
|
return node;
|
|
|
|
function addMappingWithCode(mapping, code) {
|
|
if (mapping === null || mapping.source === undefined) {
|
|
node.add(code);
|
|
} else {
|
|
var source = aRelativePath
|
|
? util.join(aRelativePath, mapping.source)
|
|
: mapping.source;
|
|
node.add(new SourceNode(mapping.originalLine,
|
|
mapping.originalColumn,
|
|
source,
|
|
code,
|
|
mapping.name));
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add a chunk of generated JS to this source node.
|
|
*
|
|
* @param aChunk A string snippet of generated JS code, another instance of
|
|
* SourceNode, or an array where each member is one of those things.
|
|
*/
|
|
SourceNode.prototype.add = function SourceNode_add(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
aChunk.forEach(function (chunk) {
|
|
this.add(chunk);
|
|
}, this);
|
|
}
|
|
else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
if (aChunk) {
|
|
this.children.push(aChunk);
|
|
}
|
|
}
|
|
else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
|
);
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add a chunk of generated JS to the beginning of this source node.
|
|
*
|
|
* @param aChunk A string snippet of generated JS code, another instance of
|
|
* SourceNode, or an array where each member is one of those things.
|
|
*/
|
|
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
for (var i = aChunk.length-1; i >= 0; i--) {
|
|
this.prepend(aChunk[i]);
|
|
}
|
|
}
|
|
else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
this.children.unshift(aChunk);
|
|
}
|
|
else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
|
);
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Walk over the tree of JS snippets in this node and its children. The
|
|
* walking function is called once for each snippet of JS and is passed that
|
|
* snippet and the its original associated source's line/column location.
|
|
*
|
|
* @param aFn The traversal function.
|
|
*/
|
|
SourceNode.prototype.walk = function SourceNode_walk(aFn) {
|
|
var chunk;
|
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
|
chunk = this.children[i];
|
|
if (chunk[isSourceNode]) {
|
|
chunk.walk(aFn);
|
|
}
|
|
else {
|
|
if (chunk !== '') {
|
|
aFn(chunk, { source: this.source,
|
|
line: this.line,
|
|
column: this.column,
|
|
name: this.name });
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
|
|
* each of `this.children`.
|
|
*
|
|
* @param aSep The separator.
|
|
*/
|
|
SourceNode.prototype.join = function SourceNode_join(aSep) {
|
|
var newChildren;
|
|
var i;
|
|
var len = this.children.length;
|
|
if (len > 0) {
|
|
newChildren = [];
|
|
for (i = 0; i < len-1; i++) {
|
|
newChildren.push(this.children[i]);
|
|
newChildren.push(aSep);
|
|
}
|
|
newChildren.push(this.children[i]);
|
|
this.children = newChildren;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Call String.prototype.replace on the very right-most source snippet. Useful
|
|
* for trimming whitespace from the end of a source node, etc.
|
|
*
|
|
* @param aPattern The pattern to replace.
|
|
* @param aReplacement The thing to replace the pattern with.
|
|
*/
|
|
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
|
|
var lastChild = this.children[this.children.length - 1];
|
|
if (lastChild[isSourceNode]) {
|
|
lastChild.replaceRight(aPattern, aReplacement);
|
|
}
|
|
else if (typeof lastChild === 'string') {
|
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
|
|
}
|
|
else {
|
|
this.children.push(''.replace(aPattern, aReplacement));
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set the source content for a source file. This will be added to the SourceMapGenerator
|
|
* in the sourcesContent field.
|
|
*
|
|
* @param aSourceFile The filename of the source file
|
|
* @param aSourceContent The content of the source file
|
|
*/
|
|
SourceNode.prototype.setSourceContent =
|
|
function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
|
|
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
|
|
};
|
|
|
|
/**
|
|
* Walk over the tree of SourceNodes. The walking function is called for each
|
|
* source file content and is passed the filename and source content.
|
|
*
|
|
* @param aFn The traversal function.
|
|
*/
|
|
SourceNode.prototype.walkSourceContents =
|
|
function SourceNode_walkSourceContents(aFn) {
|
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
|
if (this.children[i][isSourceNode]) {
|
|
this.children[i].walkSourceContents(aFn);
|
|
}
|
|
}
|
|
|
|
var sources = Object.keys(this.sourceContents);
|
|
for (var i = 0, len = sources.length; i < len; i++) {
|
|
aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Return the string representation of this source node. Walks over the tree
|
|
* and concatenates all the various snippets together to one string.
|
|
*/
|
|
SourceNode.prototype.toString = function SourceNode_toString() {
|
|
var str = "";
|
|
this.walk(function (chunk) {
|
|
str += chunk;
|
|
});
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Returns the string representation of this source node along with a source
|
|
* map.
|
|
*/
|
|
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
|
|
var generated = {
|
|
code: "",
|
|
line: 1,
|
|
column: 0
|
|
};
|
|
var map = new SourceMapGenerator(aArgs);
|
|
var sourceMappingActive = false;
|
|
var lastOriginalSource = null;
|
|
var lastOriginalLine = null;
|
|
var lastOriginalColumn = null;
|
|
var lastOriginalName = null;
|
|
this.walk(function (chunk, original) {
|
|
generated.code += chunk;
|
|
if (original.source !== null
|
|
&& original.line !== null
|
|
&& original.column !== null) {
|
|
if(lastOriginalSource !== original.source
|
|
|| lastOriginalLine !== original.line
|
|
|| lastOriginalColumn !== original.column
|
|
|| lastOriginalName !== original.name) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
lastOriginalSource = original.source;
|
|
lastOriginalLine = original.line;
|
|
lastOriginalColumn = original.column;
|
|
lastOriginalName = original.name;
|
|
sourceMappingActive = true;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
}
|
|
});
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
}
|
|
for (var idx = 0, length = chunk.length; idx < length; idx++) {
|
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
|
|
generated.line++;
|
|
generated.column = 0;
|
|
// Mappings end at eol
|
|
if (idx + 1 === length) {
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
} else {
|
|
generated.column++;
|
|
}
|
|
}
|
|
});
|
|
this.walkSourceContents(function (sourceFile, sourceContent) {
|
|
map.setSourceContent(sourceFile, sourceContent);
|
|
});
|
|
|
|
return { code: generated.code, map: map };
|
|
};
|
|
|
|
exports.SourceNode = SourceNode;
|
|
|
|
});
|
|
|
|
},{"./source-map-generator":24,"./util":26,"amdefine":5}],26:[function(require,module,exports){
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
if (typeof define !== 'function') {
|
|
var define = require('amdefine')(module, require);
|
|
}
|
|
define(function (require, exports, module) {
|
|
|
|
/**
|
|
* This is a helper function for getting values from parameter/options
|
|
* objects.
|
|
*
|
|
* @param args The object we are extracting values from
|
|
* @param name The name of the property we are getting.
|
|
* @param defaultValue An optional value to return if the property is missing
|
|
* from the object. If this is not specified and the property is missing, an
|
|
* error will be thrown.
|
|
*/
|
|
function getArg(aArgs, aName, aDefaultValue) {
|
|
if (aName in aArgs) {
|
|
return aArgs[aName];
|
|
} else if (arguments.length === 3) {
|
|
return aDefaultValue;
|
|
} else {
|
|
throw new Error('"' + aName + '" is a required argument.');
|
|
}
|
|
}
|
|
exports.getArg = getArg;
|
|
|
|
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
|
|
var dataUrlRegexp = /^data:.+\,.+$/;
|
|
|
|
function urlParse(aUrl) {
|
|
var match = aUrl.match(urlRegexp);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
return {
|
|
scheme: match[1],
|
|
auth: match[2],
|
|
host: match[3],
|
|
port: match[4],
|
|
path: match[5]
|
|
};
|
|
}
|
|
exports.urlParse = urlParse;
|
|
|
|
function urlGenerate(aParsedUrl) {
|
|
var url = '';
|
|
if (aParsedUrl.scheme) {
|
|
url += aParsedUrl.scheme + ':';
|
|
}
|
|
url += '//';
|
|
if (aParsedUrl.auth) {
|
|
url += aParsedUrl.auth + '@';
|
|
}
|
|
if (aParsedUrl.host) {
|
|
url += aParsedUrl.host;
|
|
}
|
|
if (aParsedUrl.port) {
|
|
url += ":" + aParsedUrl.port
|
|
}
|
|
if (aParsedUrl.path) {
|
|
url += aParsedUrl.path;
|
|
}
|
|
return url;
|
|
}
|
|
exports.urlGenerate = urlGenerate;
|
|
|
|
/**
|
|
* Normalizes a path, or the path portion of a URL:
|
|
*
|
|
* - Replaces consequtive slashes with one slash.
|
|
* - Removes unnecessary '.' parts.
|
|
* - Removes unnecessary '<dir>/..' parts.
|
|
*
|
|
* Based on code in the Node.js 'path' core module.
|
|
*
|
|
* @param aPath The path or url to normalize.
|
|
*/
|
|
function normalize(aPath) {
|
|
var path = aPath;
|
|
var url = urlParse(aPath);
|
|
if (url) {
|
|
if (!url.path) {
|
|
return aPath;
|
|
}
|
|
path = url.path;
|
|
}
|
|
var isAbsolute = (path.charAt(0) === '/');
|
|
|
|
var parts = path.split(/\/+/);
|
|
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
|
|
part = parts[i];
|
|
if (part === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (part === '..') {
|
|
up++;
|
|
} else if (up > 0) {
|
|
if (part === '') {
|
|
// The first part is blank if the path is absolute. Trying to go
|
|
// above the root is a no-op. Therefore we can remove all '..' parts
|
|
// directly after the root.
|
|
parts.splice(i + 1, up);
|
|
up = 0;
|
|
} else {
|
|
parts.splice(i, 2);
|
|
up--;
|
|
}
|
|
}
|
|
}
|
|
path = parts.join('/');
|
|
|
|
if (path === '') {
|
|
path = isAbsolute ? '/' : '.';
|
|
}
|
|
|
|
if (url) {
|
|
url.path = path;
|
|
return urlGenerate(url);
|
|
}
|
|
return path;
|
|
}
|
|
exports.normalize = normalize;
|
|
|
|
/**
|
|
* Joins two paths/URLs.
|
|
*
|
|
* @param aRoot The root path or URL.
|
|
* @param aPath The path or URL to be joined with the root.
|
|
*
|
|
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
|
|
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
|
|
* first.
|
|
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
|
|
* is updated with the result and aRoot is returned. Otherwise the result
|
|
* is returned.
|
|
* - If aPath is absolute, the result is aPath.
|
|
* - Otherwise the two paths are joined with a slash.
|
|
* - Joining for example 'http://' and 'www.example.com' is also supported.
|
|
*/
|
|
function join(aRoot, aPath) {
|
|
if (aRoot === "") {
|
|
aRoot = ".";
|
|
}
|
|
if (aPath === "") {
|
|
aPath = ".";
|
|
}
|
|
var aPathUrl = urlParse(aPath);
|
|
var aRootUrl = urlParse(aRoot);
|
|
if (aRootUrl) {
|
|
aRoot = aRootUrl.path || '/';
|
|
}
|
|
|
|
// `join(foo, '//www.example.org')`
|
|
if (aPathUrl && !aPathUrl.scheme) {
|
|
if (aRootUrl) {
|
|
aPathUrl.scheme = aRootUrl.scheme;
|
|
}
|
|
return urlGenerate(aPathUrl);
|
|
}
|
|
|
|
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
|
return aPath;
|
|
}
|
|
|
|
// `join('http://', 'www.example.com')`
|
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
|
aRootUrl.host = aPath;
|
|
return urlGenerate(aRootUrl);
|
|
}
|
|
|
|
var joined = aPath.charAt(0) === '/'
|
|
? aPath
|
|
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
|
|
|
|
if (aRootUrl) {
|
|
aRootUrl.path = joined;
|
|
return urlGenerate(aRootUrl);
|
|
}
|
|
return joined;
|
|
}
|
|
exports.join = join;
|
|
|
|
/**
|
|
* Make a path relative to a URL or another path.
|
|
*
|
|
* @param aRoot The root path or URL.
|
|
* @param aPath The path or URL to be made relative to aRoot.
|
|
*/
|
|
function relative(aRoot, aPath) {
|
|
if (aRoot === "") {
|
|
aRoot = ".";
|
|
}
|
|
|
|
aRoot = aRoot.replace(/\/$/, '');
|
|
|
|
// XXX: It is possible to remove this block, and the tests still pass!
|
|
var url = urlParse(aRoot);
|
|
if (aPath.charAt(0) == "/" && url && url.path == "/") {
|
|
return aPath.slice(1);
|
|
}
|
|
|
|
return aPath.indexOf(aRoot + '/') === 0
|
|
? aPath.substr(aRoot.length + 1)
|
|
: aPath;
|
|
}
|
|
exports.relative = relative;
|
|
|
|
/**
|
|
* Because behavior goes wacky when you set `__proto__` on objects, we
|
|
* have to prefix all the strings in our set with an arbitrary character.
|
|
*
|
|
* See https://github.com/mozilla/source-map/pull/31 and
|
|
* https://github.com/mozilla/source-map/issues/30
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
function toSetString(aStr) {
|
|
return '$' + aStr;
|
|
}
|
|
exports.toSetString = toSetString;
|
|
|
|
function fromSetString(aStr) {
|
|
return aStr.substr(1);
|
|
}
|
|
exports.fromSetString = fromSetString;
|
|
|
|
function strcmp(aStr1, aStr2) {
|
|
var s1 = aStr1 || "";
|
|
var s2 = aStr2 || "";
|
|
return (s1 > s2) - (s1 < s2);
|
|
}
|
|
|
|
/**
|
|
* Comparator between two mappings where the original positions are compared.
|
|
*
|
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
|
* mappings with the same original source/line/column, but different generated
|
|
* line and column the same. Useful when searching for a mapping with a
|
|
* stubbed out mapping.
|
|
*/
|
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
|
var cmp;
|
|
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp || onlyCompareOriginal) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = strcmp(mappingA.name, mappingB.name);
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
return mappingA.generatedColumn - mappingB.generatedColumn;
|
|
};
|
|
exports.compareByOriginalPositions = compareByOriginalPositions;
|
|
|
|
/**
|
|
* Comparator between two mappings where the generated positions are
|
|
* compared.
|
|
*
|
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
|
* mappings with the same generated line and column, but different
|
|
* source/name/original line and column the same. Useful when searching for a
|
|
* mapping with a stubbed out mapping.
|
|
*/
|
|
function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
|
|
var cmp;
|
|
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp || onlyCompareGenerated) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
};
|
|
exports.compareByGeneratedPositions = compareByGeneratedPositions;
|
|
|
|
});
|
|
|
|
},{"amdefine":5}],27:[function(require,module,exports){
|
|
// Copyright 2014 Simon Lydell
|
|
// X11 (“MIT”) Licensed. (See LICENSE.)
|
|
|
|
var path = require("path")
|
|
|
|
"use strict"
|
|
|
|
function urix(aPath) {
|
|
if (path.sep === "\\") {
|
|
return aPath
|
|
.replace(/\\/g, "/")
|
|
.replace(/^[a-z]:\/?/i, "/")
|
|
}
|
|
return aPath
|
|
}
|
|
|
|
module.exports = urix
|
|
|
|
},{"path":2}]},{},[4]);
|