13717 lines
374 KiB
JavaScript
13717 lines
374 KiB
JavaScript
'use strict';
|
|
|
|
var path = require('path');
|
|
var url = require('url');
|
|
var CloneHelper = require('clone');
|
|
|
|
var environment = {
|
|
encodeBase64: function encodeBase64(str) {
|
|
// Avoid Buffer constructor on newer versions of Node.js.
|
|
var buffer = Buffer.from ? Buffer.from(str) : new Buffer(str);
|
|
return buffer.toString('base64');
|
|
},
|
|
mimeLookup: function mimeLookup(filename) {
|
|
return require('mime').lookup(filename);
|
|
},
|
|
charsetLookup: function charsetLookup(mime) {
|
|
return require('mime').charsets.lookup(mime);
|
|
},
|
|
getSourceMapGenerator: function getSourceMapGenerator() {
|
|
return require('source-map').SourceMapGenerator;
|
|
}
|
|
};
|
|
|
|
function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
|
|
function _defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
}
|
|
|
|
function _inherits(subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) _setPrototypeOf(subClass, superClass);
|
|
}
|
|
|
|
function _getPrototypeOf(o) {
|
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
|
|
return o.__proto__ || Object.getPrototypeOf(o);
|
|
};
|
|
return _getPrototypeOf(o);
|
|
}
|
|
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
|
|
o.__proto__ = p;
|
|
return o;
|
|
};
|
|
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
|
|
function isNativeReflectConstruct() {
|
|
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
|
|
if (Reflect.construct.sham) return false;
|
|
if (typeof Proxy === "function") return true;
|
|
|
|
try {
|
|
Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function _construct(Parent, args, Class) {
|
|
if (isNativeReflectConstruct()) {
|
|
_construct = Reflect.construct;
|
|
} else {
|
|
_construct = function _construct(Parent, args, Class) {
|
|
var a = [null];
|
|
a.push.apply(a, args);
|
|
var Constructor = Function.bind.apply(Parent, a);
|
|
var instance = new Constructor();
|
|
if (Class) _setPrototypeOf(instance, Class.prototype);
|
|
return instance;
|
|
};
|
|
}
|
|
|
|
return _construct.apply(null, arguments);
|
|
}
|
|
|
|
function _assertThisInitialized(self) {
|
|
if (self === void 0) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
function _possibleConstructorReturn(self, call) {
|
|
if (call && (typeof call === "object" || typeof call === "function")) {
|
|
return call;
|
|
}
|
|
|
|
return _assertThisInitialized(self);
|
|
}
|
|
|
|
function _toConsumableArray(arr) {
|
|
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
|
|
}
|
|
|
|
function _arrayWithoutHoles(arr) {
|
|
if (Array.isArray(arr)) {
|
|
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
|
|
|
return arr2;
|
|
}
|
|
}
|
|
|
|
function _iterableToArray(iter) {
|
|
if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
|
|
}
|
|
|
|
function _nonIterableSpread() {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance");
|
|
}
|
|
|
|
var fs;
|
|
|
|
try {
|
|
fs = require('graceful-fs');
|
|
} catch (e) {
|
|
fs = require('fs');
|
|
}
|
|
|
|
var fs$1 = fs;
|
|
|
|
var AbstractFileManager =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function AbstractFileManager() {
|
|
_classCallCheck(this, AbstractFileManager);
|
|
}
|
|
|
|
_createClass(AbstractFileManager, [{
|
|
key: "getPath",
|
|
value: function getPath(filename) {
|
|
var j = filename.lastIndexOf('?');
|
|
|
|
if (j > 0) {
|
|
filename = filename.slice(0, j);
|
|
}
|
|
|
|
j = filename.lastIndexOf('/');
|
|
|
|
if (j < 0) {
|
|
j = filename.lastIndexOf('\\');
|
|
}
|
|
|
|
if (j < 0) {
|
|
return '';
|
|
}
|
|
|
|
return filename.slice(0, j + 1);
|
|
}
|
|
}, {
|
|
key: "tryAppendExtension",
|
|
value: function tryAppendExtension(path, ext) {
|
|
return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + ext;
|
|
}
|
|
}, {
|
|
key: "tryAppendLessExtension",
|
|
value: function tryAppendLessExtension(path) {
|
|
return this.tryAppendExtension(path, '.less');
|
|
}
|
|
}, {
|
|
key: "supportsSync",
|
|
value: function supportsSync() {
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "alwaysMakePathsAbsolute",
|
|
value: function alwaysMakePathsAbsolute() {
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isPathAbsolute",
|
|
value: function isPathAbsolute(filename) {
|
|
return /^(?:[a-z-]+:|\/|\\|#)/i.test(filename);
|
|
} // TODO: pull out / replace?
|
|
|
|
}, {
|
|
key: "join",
|
|
value: function join(basePath, laterPath) {
|
|
if (!basePath) {
|
|
return laterPath;
|
|
}
|
|
|
|
return basePath + laterPath;
|
|
}
|
|
}, {
|
|
key: "pathDiff",
|
|
value: function pathDiff(url, baseUrl) {
|
|
// diff between two paths to create a relative path
|
|
var urlParts = this.extractUrlParts(url);
|
|
var baseUrlParts = this.extractUrlParts(baseUrl);
|
|
var i;
|
|
var max;
|
|
var urlDirectories;
|
|
var baseUrlDirectories;
|
|
var diff = '';
|
|
|
|
if (urlParts.hostPart !== baseUrlParts.hostPart) {
|
|
return '';
|
|
}
|
|
|
|
max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
if (baseUrlParts.directories[i] !== urlParts.directories[i]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
baseUrlDirectories = baseUrlParts.directories.slice(i);
|
|
urlDirectories = urlParts.directories.slice(i);
|
|
|
|
for (i = 0; i < baseUrlDirectories.length - 1; i++) {
|
|
diff += '../';
|
|
}
|
|
|
|
for (i = 0; i < urlDirectories.length - 1; i++) {
|
|
diff += `${urlDirectories[i]}/`;
|
|
}
|
|
|
|
return diff;
|
|
}
|
|
}, {
|
|
key: "extractUrlParts",
|
|
// helper function, not part of API
|
|
value: function extractUrlParts(url, baseUrl) {
|
|
// urlParts[1] = protocol://hostname/ OR /
|
|
// urlParts[2] = / if path relative to host base
|
|
// urlParts[3] = directories
|
|
// urlParts[4] = filename
|
|
// urlParts[5] = parameters
|
|
var urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i;
|
|
var urlParts = url.match(urlPartsRegex);
|
|
var returner = {};
|
|
var rawDirectories = [];
|
|
var directories = [];
|
|
var i;
|
|
var baseUrlParts;
|
|
|
|
if (!urlParts) {
|
|
throw new Error(`Could not parse sheet href - '${url}'`);
|
|
} // Stylesheets in IE don't always return the full path
|
|
|
|
|
|
if (baseUrl && (!urlParts[1] || urlParts[2])) {
|
|
baseUrlParts = baseUrl.match(urlPartsRegex);
|
|
|
|
if (!baseUrlParts) {
|
|
throw new Error(`Could not parse page url - '${baseUrl}'`);
|
|
}
|
|
|
|
urlParts[1] = urlParts[1] || baseUrlParts[1] || '';
|
|
|
|
if (!urlParts[2]) {
|
|
urlParts[3] = baseUrlParts[3] + urlParts[3];
|
|
}
|
|
}
|
|
|
|
if (urlParts[3]) {
|
|
rawDirectories = urlParts[3].replace(/\\/g, '/').split('/'); // collapse '..' and skip '.'
|
|
|
|
for (i = 0; i < rawDirectories.length; i++) {
|
|
if (rawDirectories[i] === '..') {
|
|
directories.pop();
|
|
} else if (rawDirectories[i] !== '.') {
|
|
directories.push(rawDirectories[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
returner.hostPart = urlParts[1];
|
|
returner.directories = directories;
|
|
returner.rawPath = (urlParts[1] || '') + rawDirectories.join('/');
|
|
returner.path = (urlParts[1] || '') + directories.join('/');
|
|
returner.filename = urlParts[4];
|
|
returner.fileUrl = returner.path + (urlParts[4] || '');
|
|
returner.url = returner.fileUrl + (urlParts[5] || '');
|
|
return returner;
|
|
}
|
|
}]);
|
|
|
|
return AbstractFileManager;
|
|
}();
|
|
|
|
var FileManager =
|
|
/*#__PURE__*/
|
|
function (_AbstractFileManager) {
|
|
_inherits(FileManager, _AbstractFileManager);
|
|
|
|
function FileManager() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, FileManager);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(FileManager).call(this));
|
|
_this.contents = {};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(FileManager, [{
|
|
key: "supports",
|
|
value: function supports(filename, currentDirectory, options, environment) {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "supportsSync",
|
|
value: function supportsSync(filename, currentDirectory, options, environment) {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "loadFile",
|
|
value: function loadFile(filename, currentDirectory, options, environment, callback) {
|
|
var fullFilename;
|
|
var isAbsoluteFilename = this.isPathAbsolute(filename);
|
|
var filenamesTried = [];
|
|
var self = this;
|
|
var prefix = filename.slice(0, 1);
|
|
var explicit = prefix === '.' || prefix === '/';
|
|
var result = null;
|
|
var isNodeModule = false;
|
|
var npmPrefix = 'npm://';
|
|
options = options || {};
|
|
var paths = isAbsoluteFilename ? [''] : [currentDirectory];
|
|
|
|
if (options.paths) {
|
|
paths.push.apply(paths, _toConsumableArray(options.paths));
|
|
}
|
|
|
|
if (!isAbsoluteFilename && paths.indexOf('.') === -1) {
|
|
paths.push('.');
|
|
}
|
|
|
|
var prefixes = options.prefixes || [''];
|
|
var fileParts = this.extractUrlParts(filename);
|
|
|
|
if (options.syncImport) {
|
|
getFileData(returnData, returnData);
|
|
|
|
if (callback) {
|
|
callback(result.error, result);
|
|
} else {
|
|
return result;
|
|
}
|
|
} else {
|
|
// promise is guaranteed to be asyncronous
|
|
// which helps as it allows the file handle
|
|
// to be closed before it continues with the next file
|
|
return new Promise(getFileData);
|
|
}
|
|
|
|
function returnData(data) {
|
|
if (!data.filename) {
|
|
result = {
|
|
error: data
|
|
};
|
|
} else {
|
|
result = data;
|
|
}
|
|
}
|
|
|
|
function getFileData(fulfill, reject) {
|
|
(function tryPathIndex(i) {
|
|
if (i < paths.length) {
|
|
(function tryPrefix(j) {
|
|
if (j < prefixes.length) {
|
|
isNodeModule = false;
|
|
fullFilename = fileParts.rawPath + prefixes[j] + fileParts.filename;
|
|
|
|
if (paths[i]) {
|
|
fullFilename = path.join(paths[i], fullFilename);
|
|
}
|
|
|
|
if (!explicit && paths[i] === '.') {
|
|
try {
|
|
fullFilename = require.resolve(fullFilename);
|
|
isNodeModule = true;
|
|
} catch (e) {
|
|
filenamesTried.push(npmPrefix + fullFilename);
|
|
tryWithExtension();
|
|
}
|
|
} else {
|
|
tryWithExtension();
|
|
}
|
|
|
|
function tryWithExtension() {
|
|
var extFilename = options.ext ? self.tryAppendExtension(fullFilename, options.ext) : fullFilename;
|
|
|
|
if (extFilename !== fullFilename && !explicit && paths[i] === '.') {
|
|
try {
|
|
fullFilename = require.resolve(extFilename);
|
|
isNodeModule = true;
|
|
} catch (e) {
|
|
filenamesTried.push(npmPrefix + extFilename);
|
|
fullFilename = extFilename;
|
|
}
|
|
} else {
|
|
fullFilename = extFilename;
|
|
}
|
|
}
|
|
|
|
var modified = false;
|
|
|
|
if (self.contents[fullFilename]) {
|
|
try {
|
|
var stat = fs$1.statSync.apply(this, [fullFilename]);
|
|
|
|
if (stat.mtime.getTime() === self.contents[fullFilename].mtime.getTime()) {
|
|
fulfill({
|
|
contents: self.contents[fullFilename].data,
|
|
filename: fullFilename
|
|
});
|
|
} else {
|
|
modified = true;
|
|
}
|
|
} catch (e) {
|
|
modified = true;
|
|
}
|
|
}
|
|
|
|
if (modified || !self.contents[fullFilename]) {
|
|
var readFileArgs = [fullFilename];
|
|
|
|
if (!options.rawBuffer) {
|
|
readFileArgs.push('utf-8');
|
|
}
|
|
|
|
if (options.syncImport) {
|
|
try {
|
|
var data = fs$1.readFileSync.apply(this, readFileArgs);
|
|
var stat = fs$1.statSync.apply(this, [fullFilename]);
|
|
self.contents[fullFilename] = {
|
|
data,
|
|
mtime: stat.mtime
|
|
};
|
|
fulfill({
|
|
contents: data,
|
|
filename: fullFilename
|
|
});
|
|
} catch (e) {
|
|
filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);
|
|
return tryPrefix(j + 1);
|
|
}
|
|
} else {
|
|
readFileArgs.push(function (e, data) {
|
|
if (e) {
|
|
filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);
|
|
return tryPrefix(j + 1);
|
|
}
|
|
|
|
var stat = fs$1.statSync.apply(this, [fullFilename]);
|
|
self.contents[fullFilename] = {
|
|
data,
|
|
mtime: stat.mtime
|
|
};
|
|
fulfill({
|
|
contents: data,
|
|
filename: fullFilename
|
|
});
|
|
});
|
|
fs$1.readFile.apply(this, readFileArgs);
|
|
}
|
|
}
|
|
} else {
|
|
tryPathIndex(i + 1);
|
|
}
|
|
})(0);
|
|
} else {
|
|
reject({
|
|
type: 'File',
|
|
message: `'${filename}' wasn't found. Tried - ${filenamesTried.join(',')}`
|
|
});
|
|
}
|
|
})(0);
|
|
}
|
|
}
|
|
}, {
|
|
key: "loadFileSync",
|
|
value: function loadFileSync(filename, currentDirectory, options, environment) {
|
|
options.syncImport = true;
|
|
return this.loadFile(filename, currentDirectory, options, environment);
|
|
}
|
|
}]);
|
|
|
|
return FileManager;
|
|
}(AbstractFileManager);
|
|
|
|
var logger = {
|
|
error: function error(msg) {
|
|
this._fireEvent('error', msg);
|
|
},
|
|
warn: function warn(msg) {
|
|
this._fireEvent('warn', msg);
|
|
},
|
|
info: function info(msg) {
|
|
this._fireEvent('info', msg);
|
|
},
|
|
debug: function debug(msg) {
|
|
this._fireEvent('debug', msg);
|
|
},
|
|
addListener: function addListener(listener) {
|
|
this._listeners.push(listener);
|
|
},
|
|
removeListener: function removeListener(listener) {
|
|
for (var i = 0; i < this._listeners.length; i++) {
|
|
if (this._listeners[i] === listener) {
|
|
this._listeners.splice(i, 1);
|
|
|
|
return;
|
|
}
|
|
}
|
|
},
|
|
_fireEvent: function _fireEvent(type, msg) {
|
|
for (var i = 0; i < this._listeners.length; i++) {
|
|
var logFunction = this._listeners[i][type];
|
|
|
|
if (logFunction) {
|
|
logFunction(msg);
|
|
}
|
|
}
|
|
},
|
|
_listeners: []
|
|
};
|
|
|
|
var isUrlRe = /^(?:https?:)?\/\//i;
|
|
var request;
|
|
|
|
var UrlFileManager =
|
|
/*#__PURE__*/
|
|
function (_AbstractFileManager) {
|
|
_inherits(UrlFileManager, _AbstractFileManager);
|
|
|
|
function UrlFileManager() {
|
|
_classCallCheck(this, UrlFileManager);
|
|
|
|
return _possibleConstructorReturn(this, _getPrototypeOf(UrlFileManager).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(UrlFileManager, [{
|
|
key: "supports",
|
|
value: function supports(filename, currentDirectory, options, environment) {
|
|
return isUrlRe.test(filename) || isUrlRe.test(currentDirectory);
|
|
}
|
|
}, {
|
|
key: "loadFile",
|
|
value: function loadFile(filename, currentDirectory, options, environment) {
|
|
return new Promise(function (fulfill, reject) {
|
|
if (request === undefined) {
|
|
try {
|
|
request = require('request');
|
|
} catch (e) {
|
|
request = null;
|
|
}
|
|
}
|
|
|
|
if (!request) {
|
|
reject({
|
|
type: 'File',
|
|
message: 'optional dependency \'request\' required to import over http(s)\n'
|
|
});
|
|
return;
|
|
}
|
|
|
|
var urlStr = isUrlRe.test(filename) ? filename : url.resolve(currentDirectory, filename);
|
|
var urlObj = url.parse(urlStr);
|
|
|
|
if (!urlObj.protocol) {
|
|
urlObj.protocol = 'http';
|
|
urlStr = urlObj.format();
|
|
}
|
|
|
|
request.get({
|
|
uri: urlStr,
|
|
strictSSL: !options.insecure
|
|
}, function (error, res, body) {
|
|
if (error) {
|
|
reject({
|
|
type: 'File',
|
|
message: `resource '${urlStr}' gave this Error:\n ${error}\n`
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (res && res.statusCode === 404) {
|
|
reject({
|
|
type: 'File',
|
|
message: `resource '${urlStr}' was not found\n`
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!body) {
|
|
logger.warn(`Warning: Empty body (HTTP ${res.statusCode}) returned by "${urlStr}"`);
|
|
}
|
|
|
|
fulfill({
|
|
contents: body,
|
|
filename: urlStr
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return UrlFileManager;
|
|
}(AbstractFileManager);
|
|
|
|
var colors = {
|
|
'aliceblue': '#f0f8ff',
|
|
'antiquewhite': '#faebd7',
|
|
'aqua': '#00ffff',
|
|
'aquamarine': '#7fffd4',
|
|
'azure': '#f0ffff',
|
|
'beige': '#f5f5dc',
|
|
'bisque': '#ffe4c4',
|
|
'black': '#000000',
|
|
'blanchedalmond': '#ffebcd',
|
|
'blue': '#0000ff',
|
|
'blueviolet': '#8a2be2',
|
|
'brown': '#a52a2a',
|
|
'burlywood': '#deb887',
|
|
'cadetblue': '#5f9ea0',
|
|
'chartreuse': '#7fff00',
|
|
'chocolate': '#d2691e',
|
|
'coral': '#ff7f50',
|
|
'cornflowerblue': '#6495ed',
|
|
'cornsilk': '#fff8dc',
|
|
'crimson': '#dc143c',
|
|
'cyan': '#00ffff',
|
|
'darkblue': '#00008b',
|
|
'darkcyan': '#008b8b',
|
|
'darkgoldenrod': '#b8860b',
|
|
'darkgray': '#a9a9a9',
|
|
'darkgrey': '#a9a9a9',
|
|
'darkgreen': '#006400',
|
|
'darkkhaki': '#bdb76b',
|
|
'darkmagenta': '#8b008b',
|
|
'darkolivegreen': '#556b2f',
|
|
'darkorange': '#ff8c00',
|
|
'darkorchid': '#9932cc',
|
|
'darkred': '#8b0000',
|
|
'darksalmon': '#e9967a',
|
|
'darkseagreen': '#8fbc8f',
|
|
'darkslateblue': '#483d8b',
|
|
'darkslategray': '#2f4f4f',
|
|
'darkslategrey': '#2f4f4f',
|
|
'darkturquoise': '#00ced1',
|
|
'darkviolet': '#9400d3',
|
|
'deeppink': '#ff1493',
|
|
'deepskyblue': '#00bfff',
|
|
'dimgray': '#696969',
|
|
'dimgrey': '#696969',
|
|
'dodgerblue': '#1e90ff',
|
|
'firebrick': '#b22222',
|
|
'floralwhite': '#fffaf0',
|
|
'forestgreen': '#228b22',
|
|
'fuchsia': '#ff00ff',
|
|
'gainsboro': '#dcdcdc',
|
|
'ghostwhite': '#f8f8ff',
|
|
'gold': '#ffd700',
|
|
'goldenrod': '#daa520',
|
|
'gray': '#808080',
|
|
'grey': '#808080',
|
|
'green': '#008000',
|
|
'greenyellow': '#adff2f',
|
|
'honeydew': '#f0fff0',
|
|
'hotpink': '#ff69b4',
|
|
'indianred': '#cd5c5c',
|
|
'indigo': '#4b0082',
|
|
'ivory': '#fffff0',
|
|
'khaki': '#f0e68c',
|
|
'lavender': '#e6e6fa',
|
|
'lavenderblush': '#fff0f5',
|
|
'lawngreen': '#7cfc00',
|
|
'lemonchiffon': '#fffacd',
|
|
'lightblue': '#add8e6',
|
|
'lightcoral': '#f08080',
|
|
'lightcyan': '#e0ffff',
|
|
'lightgoldenrodyellow': '#fafad2',
|
|
'lightgray': '#d3d3d3',
|
|
'lightgrey': '#d3d3d3',
|
|
'lightgreen': '#90ee90',
|
|
'lightpink': '#ffb6c1',
|
|
'lightsalmon': '#ffa07a',
|
|
'lightseagreen': '#20b2aa',
|
|
'lightskyblue': '#87cefa',
|
|
'lightslategray': '#778899',
|
|
'lightslategrey': '#778899',
|
|
'lightsteelblue': '#b0c4de',
|
|
'lightyellow': '#ffffe0',
|
|
'lime': '#00ff00',
|
|
'limegreen': '#32cd32',
|
|
'linen': '#faf0e6',
|
|
'magenta': '#ff00ff',
|
|
'maroon': '#800000',
|
|
'mediumaquamarine': '#66cdaa',
|
|
'mediumblue': '#0000cd',
|
|
'mediumorchid': '#ba55d3',
|
|
'mediumpurple': '#9370d8',
|
|
'mediumseagreen': '#3cb371',
|
|
'mediumslateblue': '#7b68ee',
|
|
'mediumspringgreen': '#00fa9a',
|
|
'mediumturquoise': '#48d1cc',
|
|
'mediumvioletred': '#c71585',
|
|
'midnightblue': '#191970',
|
|
'mintcream': '#f5fffa',
|
|
'mistyrose': '#ffe4e1',
|
|
'moccasin': '#ffe4b5',
|
|
'navajowhite': '#ffdead',
|
|
'navy': '#000080',
|
|
'oldlace': '#fdf5e6',
|
|
'olive': '#808000',
|
|
'olivedrab': '#6b8e23',
|
|
'orange': '#ffa500',
|
|
'orangered': '#ff4500',
|
|
'orchid': '#da70d6',
|
|
'palegoldenrod': '#eee8aa',
|
|
'palegreen': '#98fb98',
|
|
'paleturquoise': '#afeeee',
|
|
'palevioletred': '#d87093',
|
|
'papayawhip': '#ffefd5',
|
|
'peachpuff': '#ffdab9',
|
|
'peru': '#cd853f',
|
|
'pink': '#ffc0cb',
|
|
'plum': '#dda0dd',
|
|
'powderblue': '#b0e0e6',
|
|
'purple': '#800080',
|
|
'rebeccapurple': '#663399',
|
|
'red': '#ff0000',
|
|
'rosybrown': '#bc8f8f',
|
|
'royalblue': '#4169e1',
|
|
'saddlebrown': '#8b4513',
|
|
'salmon': '#fa8072',
|
|
'sandybrown': '#f4a460',
|
|
'seagreen': '#2e8b57',
|
|
'seashell': '#fff5ee',
|
|
'sienna': '#a0522d',
|
|
'silver': '#c0c0c0',
|
|
'skyblue': '#87ceeb',
|
|
'slateblue': '#6a5acd',
|
|
'slategray': '#708090',
|
|
'slategrey': '#708090',
|
|
'snow': '#fffafa',
|
|
'springgreen': '#00ff7f',
|
|
'steelblue': '#4682b4',
|
|
'tan': '#d2b48c',
|
|
'teal': '#008080',
|
|
'thistle': '#d8bfd8',
|
|
'tomato': '#ff6347',
|
|
'turquoise': '#40e0d0',
|
|
'violet': '#ee82ee',
|
|
'wheat': '#f5deb3',
|
|
'white': '#ffffff',
|
|
'whitesmoke': '#f5f5f5',
|
|
'yellow': '#ffff00',
|
|
'yellowgreen': '#9acd32'
|
|
};
|
|
|
|
var unitConversions = {
|
|
length: {
|
|
'm': 1,
|
|
'cm': 0.01,
|
|
'mm': 0.001,
|
|
'in': 0.0254,
|
|
'px': 0.0254 / 96,
|
|
'pt': 0.0254 / 72,
|
|
'pc': 0.0254 / 72 * 12
|
|
},
|
|
duration: {
|
|
's': 1,
|
|
'ms': 0.001
|
|
},
|
|
angle: {
|
|
'rad': 1 / (2 * Math.PI),
|
|
'deg': 1 / 360,
|
|
'grad': 1 / 400,
|
|
'turn': 1
|
|
}
|
|
};
|
|
|
|
var data = {
|
|
colors,
|
|
unitConversions
|
|
};
|
|
|
|
var Node =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Node() {
|
|
_classCallCheck(this, Node);
|
|
|
|
this.parent = null;
|
|
this.visibilityBlocks = undefined;
|
|
this.nodeVisible = undefined;
|
|
this.rootNode = null;
|
|
this.parsed = null;
|
|
var self = this;
|
|
Object.defineProperty(this, 'currentFileInfo', {
|
|
get: function get() {
|
|
return self.fileInfo();
|
|
}
|
|
});
|
|
Object.defineProperty(this, 'index', {
|
|
get: function get() {
|
|
return self.getIndex();
|
|
}
|
|
});
|
|
}
|
|
|
|
_createClass(Node, [{
|
|
key: "setParent",
|
|
value: function setParent(nodes, parent) {
|
|
function set(node) {
|
|
if (node && node instanceof Node) {
|
|
node.parent = parent;
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(nodes)) {
|
|
nodes.forEach(set);
|
|
} else {
|
|
set(nodes);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getIndex",
|
|
value: function getIndex() {
|
|
return this._index || this.parent && this.parent.getIndex() || 0;
|
|
}
|
|
}, {
|
|
key: "fileInfo",
|
|
value: function fileInfo() {
|
|
return this._fileInfo || this.parent && this.parent.fileInfo() || {};
|
|
}
|
|
}, {
|
|
key: "isRulesetLike",
|
|
value: function isRulesetLike() {
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "toCSS",
|
|
value: function toCSS(context) {
|
|
var strs = [];
|
|
this.genCSS(context, {
|
|
add: function add(chunk, fileInfo, index) {
|
|
strs.push(chunk);
|
|
},
|
|
isEmpty: function isEmpty() {
|
|
return strs.length === 0;
|
|
}
|
|
});
|
|
return strs.join('');
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(this.value);
|
|
}
|
|
}, {
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.value = visitor.visit(this.value);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval() {
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "_operate",
|
|
value: function _operate(context, op, a, b) {
|
|
switch (op) {
|
|
case '+':
|
|
return a + b;
|
|
|
|
case '-':
|
|
return a - b;
|
|
|
|
case '*':
|
|
return a * b;
|
|
|
|
case '/':
|
|
return a / b;
|
|
}
|
|
}
|
|
}, {
|
|
key: "fround",
|
|
value: function fround(context, value) {
|
|
var precision = context && context.numPrecision; // add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999...) are properly rounded:
|
|
|
|
return precision ? Number((value + 2e-16).toFixed(precision)) : value;
|
|
} // Returns true if this node represents root of ast imported by reference
|
|
|
|
}, {
|
|
key: "blocksVisibility",
|
|
value: function blocksVisibility() {
|
|
if (this.visibilityBlocks == null) {
|
|
this.visibilityBlocks = 0;
|
|
}
|
|
|
|
return this.visibilityBlocks !== 0;
|
|
}
|
|
}, {
|
|
key: "addVisibilityBlock",
|
|
value: function addVisibilityBlock() {
|
|
if (this.visibilityBlocks == null) {
|
|
this.visibilityBlocks = 0;
|
|
}
|
|
|
|
this.visibilityBlocks = this.visibilityBlocks + 1;
|
|
}
|
|
}, {
|
|
key: "removeVisibilityBlock",
|
|
value: function removeVisibilityBlock() {
|
|
if (this.visibilityBlocks == null) {
|
|
this.visibilityBlocks = 0;
|
|
}
|
|
|
|
this.visibilityBlocks = this.visibilityBlocks - 1;
|
|
} // Turns on node visibility - if called node will be shown in output regardless
|
|
// of whether it comes from import by reference or not
|
|
|
|
}, {
|
|
key: "ensureVisibility",
|
|
value: function ensureVisibility() {
|
|
this.nodeVisible = true;
|
|
} // Turns off node visibility - if called node will NOT be shown in output regardless
|
|
// of whether it comes from import by reference or not
|
|
|
|
}, {
|
|
key: "ensureInvisibility",
|
|
value: function ensureInvisibility() {
|
|
this.nodeVisible = false;
|
|
} // return values:
|
|
// false - the node must not be visible
|
|
// true - the node must be visible
|
|
// undefined or null - the node has the same visibility as its parent
|
|
|
|
}, {
|
|
key: "isVisible",
|
|
value: function isVisible() {
|
|
return this.nodeVisible;
|
|
}
|
|
}, {
|
|
key: "visibilityInfo",
|
|
value: function visibilityInfo() {
|
|
return {
|
|
visibilityBlocks: this.visibilityBlocks,
|
|
nodeVisible: this.nodeVisible
|
|
};
|
|
}
|
|
}, {
|
|
key: "copyVisibilityInfo",
|
|
value: function copyVisibilityInfo(info) {
|
|
if (!info) {
|
|
return;
|
|
}
|
|
|
|
this.visibilityBlocks = info.visibilityBlocks;
|
|
this.nodeVisible = info.nodeVisible;
|
|
}
|
|
}]);
|
|
|
|
return Node;
|
|
}();
|
|
|
|
Node.compare = function (a, b) {
|
|
/* returns:
|
|
-1: a < b
|
|
0: a = b
|
|
1: a > b
|
|
and *any* other value for a != b (e.g. undefined, NaN, -2 etc.) */
|
|
if (a.compare && // for "symmetric results" force toCSS-based comparison
|
|
// of Quoted or Anonymous if either value is one of those
|
|
!(b.type === 'Quoted' || b.type === 'Anonymous')) {
|
|
return a.compare(b);
|
|
} else if (b.compare) {
|
|
return -b.compare(a);
|
|
} else if (a.type !== b.type) {
|
|
return undefined;
|
|
}
|
|
|
|
a = a.value;
|
|
b = b.value;
|
|
|
|
if (!Array.isArray(a)) {
|
|
return a === b ? 0 : undefined;
|
|
}
|
|
|
|
if (a.length !== b.length) {
|
|
return undefined;
|
|
}
|
|
|
|
for (var i = 0; i < a.length; i++) {
|
|
if (Node.compare(a[i], b[i]) !== 0) {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
Node.numericCompare = function (a, b) {
|
|
return a < b ? -1 : a === b ? 0 : a > b ? 1 : undefined;
|
|
};
|
|
|
|
// RGB Colors - #ff0014, #eee
|
|
//
|
|
|
|
var Color =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Color, _Node);
|
|
|
|
function Color(rgb, a, originalForm) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Color);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Color).call(this));
|
|
|
|
var self = _assertThisInitialized(_this); //
|
|
// The end goal here, is to parse the arguments
|
|
// into an integer triplet, such as `128, 255, 0`
|
|
//
|
|
// This facilitates operations and conversions.
|
|
//
|
|
|
|
|
|
if (Array.isArray(rgb)) {
|
|
_this.rgb = rgb;
|
|
} else if (rgb.length >= 6) {
|
|
_this.rgb = [];
|
|
rgb.match(/.{2}/g).map(function (c, i) {
|
|
if (i < 3) {
|
|
self.rgb.push(parseInt(c, 16));
|
|
} else {
|
|
self.alpha = parseInt(c, 16) / 255;
|
|
}
|
|
});
|
|
} else {
|
|
_this.rgb = [];
|
|
rgb.split('').map(function (c, i) {
|
|
if (i < 3) {
|
|
self.rgb.push(parseInt(c + c, 16));
|
|
} else {
|
|
self.alpha = parseInt(c + c, 16) / 255;
|
|
}
|
|
});
|
|
}
|
|
|
|
_this.alpha = _this.alpha || (typeof a === 'number' ? a : 1);
|
|
|
|
if (typeof originalForm !== 'undefined') {
|
|
_this.value = originalForm;
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Color, [{
|
|
key: "luma",
|
|
value: function luma() {
|
|
var r = this.rgb[0] / 255;
|
|
var g = this.rgb[1] / 255;
|
|
var b = this.rgb[2] / 255;
|
|
r = r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
|
|
g = g <= 0.03928 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4);
|
|
b = b <= 0.03928 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4);
|
|
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(this.toCSS(context));
|
|
}
|
|
}, {
|
|
key: "toCSS",
|
|
value: function toCSS(context, doNotCompress) {
|
|
var compress = context && context.compress && !doNotCompress;
|
|
var color;
|
|
var alpha;
|
|
var colorFunction;
|
|
var args = []; // `value` is set if this color was originally
|
|
// converted from a named color string so we need
|
|
// to respect this and try to output named color too.
|
|
|
|
alpha = this.fround(context, this.alpha);
|
|
|
|
if (this.value) {
|
|
if (this.value.indexOf('rgb') === 0) {
|
|
if (alpha < 1) {
|
|
colorFunction = 'rgba';
|
|
}
|
|
} else if (this.value.indexOf('hsl') === 0) {
|
|
if (alpha < 1) {
|
|
colorFunction = 'hsla';
|
|
} else {
|
|
colorFunction = 'hsl';
|
|
}
|
|
} else {
|
|
return this.value;
|
|
}
|
|
} else {
|
|
if (alpha < 1) {
|
|
colorFunction = 'rgba';
|
|
}
|
|
}
|
|
|
|
switch (colorFunction) {
|
|
case 'rgba':
|
|
args = this.rgb.map(function (c) {
|
|
return clamp(Math.round(c), 255);
|
|
}).concat(clamp(alpha, 1));
|
|
break;
|
|
|
|
case 'hsla':
|
|
args.push(clamp(alpha, 1));
|
|
|
|
case 'hsl':
|
|
color = this.toHSL();
|
|
args = [this.fround(context, color.h), `${this.fround(context, color.s * 100)}%`, `${this.fround(context, color.l * 100)}%`].concat(args);
|
|
}
|
|
|
|
if (colorFunction) {
|
|
// Values are capped between `0` and `255`, rounded and zero-padded.
|
|
return `${colorFunction}(${args.join(`,${compress ? '' : ' '}`)})`;
|
|
}
|
|
|
|
color = this.toRGB();
|
|
|
|
if (compress) {
|
|
var splitcolor = color.split(''); // Convert color to short format
|
|
|
|
if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
|
|
color = `#${splitcolor[1]}${splitcolor[3]}${splitcolor[5]}`;
|
|
}
|
|
}
|
|
|
|
return color;
|
|
} //
|
|
// Operations have to be done per-channel, if not,
|
|
// channels will spill onto each other. Once we have
|
|
// our result, in the form of an integer triplet,
|
|
// we create a new Color node to hold the result.
|
|
//
|
|
|
|
}, {
|
|
key: "operate",
|
|
value: function operate(context, op, other) {
|
|
var rgb = new Array(3);
|
|
var alpha = this.alpha * (1 - other.alpha) + other.alpha;
|
|
|
|
for (var c = 0; c < 3; c++) {
|
|
rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
|
|
}
|
|
|
|
return new Color(rgb, alpha);
|
|
}
|
|
}, {
|
|
key: "toRGB",
|
|
value: function toRGB() {
|
|
return toHex(this.rgb);
|
|
}
|
|
}, {
|
|
key: "toHSL",
|
|
value: function toHSL() {
|
|
var r = this.rgb[0] / 255;
|
|
var g = this.rgb[1] / 255;
|
|
var b = this.rgb[2] / 255;
|
|
var a = this.alpha;
|
|
var max = Math.max(r, g, b);
|
|
var min = Math.min(r, g, b);
|
|
var h;
|
|
var s;
|
|
var l = (max + min) / 2;
|
|
var d = max - min;
|
|
|
|
if (max === min) {
|
|
h = s = 0;
|
|
} else {
|
|
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
|
|
|
|
switch (max) {
|
|
case r:
|
|
h = (g - b) / d + (g < b ? 6 : 0);
|
|
break;
|
|
|
|
case g:
|
|
h = (b - r) / d + 2;
|
|
break;
|
|
|
|
case b:
|
|
h = (r - g) / d + 4;
|
|
break;
|
|
}
|
|
|
|
h /= 6;
|
|
}
|
|
|
|
return {
|
|
h: h * 360,
|
|
s,
|
|
l,
|
|
a
|
|
};
|
|
} // Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
|
|
|
|
}, {
|
|
key: "toHSV",
|
|
value: function toHSV() {
|
|
var r = this.rgb[0] / 255;
|
|
var g = this.rgb[1] / 255;
|
|
var b = this.rgb[2] / 255;
|
|
var a = this.alpha;
|
|
var max = Math.max(r, g, b);
|
|
var min = Math.min(r, g, b);
|
|
var h;
|
|
var s;
|
|
var v = max;
|
|
var d = max - min;
|
|
|
|
if (max === 0) {
|
|
s = 0;
|
|
} else {
|
|
s = d / max;
|
|
}
|
|
|
|
if (max === min) {
|
|
h = 0;
|
|
} else {
|
|
switch (max) {
|
|
case r:
|
|
h = (g - b) / d + (g < b ? 6 : 0);
|
|
break;
|
|
|
|
case g:
|
|
h = (b - r) / d + 2;
|
|
break;
|
|
|
|
case b:
|
|
h = (r - g) / d + 4;
|
|
break;
|
|
}
|
|
|
|
h /= 6;
|
|
}
|
|
|
|
return {
|
|
h: h * 360,
|
|
s,
|
|
v,
|
|
a
|
|
};
|
|
}
|
|
}, {
|
|
key: "toARGB",
|
|
value: function toARGB() {
|
|
return toHex([this.alpha * 255].concat(this.rgb));
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(x) {
|
|
return x.rgb && x.rgb[0] === this.rgb[0] && x.rgb[1] === this.rgb[1] && x.rgb[2] === this.rgb[2] && x.alpha === this.alpha ? 0 : undefined;
|
|
}
|
|
}]);
|
|
|
|
return Color;
|
|
}(Node);
|
|
|
|
Color.prototype.type = 'Color';
|
|
|
|
function clamp(v, max) {
|
|
return Math.min(Math.max(v, 0), max);
|
|
}
|
|
|
|
function toHex(v) {
|
|
return `#${v.map(function (c) {
|
|
c = clamp(Math.round(c), 255);
|
|
return (c < 16 ? '0' : '') + c.toString(16);
|
|
}).join('')}`;
|
|
}
|
|
|
|
Color.fromKeyword = function (keyword) {
|
|
var c;
|
|
var key = keyword.toLowerCase();
|
|
|
|
if (colors.hasOwnProperty(key)) {
|
|
c = new Color(colors[key].slice(1));
|
|
} else if (key === 'transparent') {
|
|
c = new Color([0, 0, 0], 0);
|
|
}
|
|
|
|
if (c) {
|
|
c.value = keyword;
|
|
return c;
|
|
}
|
|
};
|
|
|
|
var Paren =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Paren, _Node);
|
|
|
|
function Paren(node) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Paren);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Paren).call(this));
|
|
_this.value = node;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Paren, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add('(');
|
|
this.value.genCSS(context, output);
|
|
output.add(')');
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return new Paren(this.value.eval(context));
|
|
}
|
|
}]);
|
|
|
|
return Paren;
|
|
}(Node);
|
|
|
|
Paren.prototype.type = 'Paren';
|
|
|
|
var _noSpaceCombinators = {
|
|
'': true,
|
|
' ': true,
|
|
'|': true
|
|
};
|
|
|
|
var Combinator =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Combinator, _Node);
|
|
|
|
function Combinator(value) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Combinator);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Combinator).call(this));
|
|
|
|
if (value === ' ') {
|
|
_this.value = ' ';
|
|
_this.emptyOrWhitespace = true;
|
|
} else {
|
|
_this.value = value ? value.trim() : '';
|
|
_this.emptyOrWhitespace = _this.value === '';
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Combinator, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
var spaceOrEmpty = context.compress || _noSpaceCombinators[this.value] ? '' : ' ';
|
|
output.add(spaceOrEmpty + this.value + spaceOrEmpty);
|
|
}
|
|
}]);
|
|
|
|
return Combinator;
|
|
}(Node);
|
|
|
|
Combinator.prototype.type = 'Combinator';
|
|
|
|
var Element =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Element, _Node);
|
|
|
|
function Element(combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Element);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Element).call(this));
|
|
_this.combinator = combinator instanceof Combinator ? combinator : new Combinator(combinator);
|
|
|
|
if (typeof value === 'string') {
|
|
_this.value = value.trim();
|
|
} else if (value) {
|
|
_this.value = value;
|
|
} else {
|
|
_this.value = '';
|
|
}
|
|
|
|
_this.isVariable = isVariable;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.setParent(_this.combinator, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Element, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
var value = this.value;
|
|
this.combinator = visitor.visit(this.combinator);
|
|
|
|
if (typeof value === 'object') {
|
|
this.value = visitor.visit(value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return new Element(this.combinator, this.value.eval ? this.value.eval(context) : this.value, this.isVariable, this.getIndex(), this.fileInfo(), this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "clone",
|
|
value: function clone() {
|
|
return new Element(this.combinator, this.value, this.isVariable, this.getIndex(), this.fileInfo(), this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
|
|
}
|
|
}, {
|
|
key: "toCSS",
|
|
value: function toCSS() {
|
|
var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
var value = this.value;
|
|
var firstSelector = context.firstSelector;
|
|
|
|
if (value instanceof Paren) {
|
|
// selector in parens should not be affected by outer selector
|
|
// flags (breaks only interpolated selectors - see #1973)
|
|
context.firstSelector = true;
|
|
}
|
|
|
|
value = value.toCSS ? value.toCSS(context) : value;
|
|
context.firstSelector = firstSelector;
|
|
|
|
if (value === '' && this.combinator.value.charAt(0) === '&') {
|
|
return '';
|
|
} else {
|
|
return this.combinator.toCSS(context) + value;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Element;
|
|
}(Node);
|
|
|
|
Element.prototype.type = 'Element';
|
|
|
|
var Math$1 = {
|
|
ALWAYS: 0,
|
|
PARENS_DIVISION: 1,
|
|
PARENS: 2,
|
|
STRICT_LEGACY: 3
|
|
};
|
|
var RewriteUrls = {
|
|
OFF: 0,
|
|
LOCAL: 1,
|
|
ALL: 2
|
|
};
|
|
|
|
/* jshint proto: true */
|
|
function getLocation(index, inputStream) {
|
|
var n = index + 1;
|
|
var line = null;
|
|
var column = -1;
|
|
|
|
while (--n >= 0 && inputStream.charAt(n) !== '\n') {
|
|
column++;
|
|
}
|
|
|
|
if (typeof index === 'number') {
|
|
line = (inputStream.slice(0, index).match(/\n/g) || '').length;
|
|
}
|
|
|
|
return {
|
|
line,
|
|
column
|
|
};
|
|
}
|
|
function copyArray(arr) {
|
|
var i;
|
|
var length = arr.length;
|
|
var copy = new Array(length);
|
|
|
|
for (i = 0; i < length; i++) {
|
|
copy[i] = arr[i];
|
|
}
|
|
|
|
return copy;
|
|
}
|
|
function clone(obj) {
|
|
var cloned = {};
|
|
|
|
for (var prop in obj) {
|
|
if (obj.hasOwnProperty(prop)) {
|
|
cloned[prop] = obj[prop];
|
|
}
|
|
}
|
|
|
|
return cloned;
|
|
}
|
|
function defaults(obj1, obj2) {
|
|
var newObj = obj2 || {};
|
|
|
|
if (!obj2._defaults) {
|
|
newObj = {};
|
|
|
|
var _defaults = CloneHelper(obj1);
|
|
|
|
newObj._defaults = _defaults;
|
|
var cloned = obj2 ? CloneHelper(obj2) : {};
|
|
Object.assign(newObj, _defaults, cloned);
|
|
}
|
|
|
|
return newObj;
|
|
}
|
|
function copyOptions(obj1, obj2) {
|
|
if (obj2 && obj2._defaults) {
|
|
return obj2;
|
|
}
|
|
|
|
var opts = defaults(obj1, obj2);
|
|
|
|
if (opts.strictMath) {
|
|
opts.math = Math$1.STRICT_LEGACY;
|
|
} // Back compat with changed relativeUrls option
|
|
|
|
|
|
if (opts.relativeUrls) {
|
|
opts.rewriteUrls = RewriteUrls.ALL;
|
|
}
|
|
|
|
if (typeof opts.math === 'string') {
|
|
switch (opts.math.toLowerCase()) {
|
|
case 'always':
|
|
opts.math = Math$1.ALWAYS;
|
|
break;
|
|
|
|
case 'parens-division':
|
|
opts.math = Math$1.PARENS_DIVISION;
|
|
break;
|
|
|
|
case 'strict':
|
|
case 'parens':
|
|
opts.math = Math$1.PARENS;
|
|
break;
|
|
|
|
case 'strict-legacy':
|
|
opts.math = Math$1.STRICT_LEGACY;
|
|
}
|
|
}
|
|
|
|
if (typeof opts.rewriteUrls === 'string') {
|
|
switch (opts.rewriteUrls.toLowerCase()) {
|
|
case 'off':
|
|
opts.rewriteUrls = RewriteUrls.OFF;
|
|
break;
|
|
|
|
case 'local':
|
|
opts.rewriteUrls = RewriteUrls.LOCAL;
|
|
break;
|
|
|
|
case 'all':
|
|
opts.rewriteUrls = RewriteUrls.ALL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return opts;
|
|
}
|
|
function merge(obj1, obj2) {
|
|
for (var prop in obj2) {
|
|
if (obj2.hasOwnProperty(prop)) {
|
|
obj1[prop] = obj2[prop];
|
|
}
|
|
}
|
|
|
|
return obj1;
|
|
}
|
|
function flattenArray(arr) {
|
|
var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
|
|
for (var i = 0, length = arr.length; i < length; i++) {
|
|
var value = arr[i];
|
|
|
|
if (Array.isArray(value)) {
|
|
flattenArray(value, result);
|
|
} else {
|
|
if (value !== undefined) {
|
|
result.push(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
var utils = /*#__PURE__*/Object.freeze({
|
|
getLocation: getLocation,
|
|
copyArray: copyArray,
|
|
clone: clone,
|
|
defaults: defaults,
|
|
copyOptions: copyOptions,
|
|
merge: merge,
|
|
flattenArray: flattenArray
|
|
});
|
|
|
|
/**
|
|
* This is a centralized class of any error that could be thrown internally (mostly by the parser).
|
|
* Besides standard .message it keeps some additional data like a path to the file where the error
|
|
* occurred along with line and column numbers.
|
|
*
|
|
* @class
|
|
* @extends Error
|
|
* @type {module.LessError}
|
|
*
|
|
* @prop {string} type
|
|
* @prop {string} filename
|
|
* @prop {number} index
|
|
* @prop {number} line
|
|
* @prop {number} column
|
|
* @prop {number} callLine
|
|
* @prop {number} callExtract
|
|
* @prop {string[]} extract
|
|
*
|
|
* @param {Object} e - An error object to wrap around or just a descriptive object
|
|
* @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
|
|
* @param {string} [currentFilename]
|
|
*/
|
|
|
|
var LessError = function LessError(e, fileContentMap, currentFilename) {
|
|
Error.call(this);
|
|
var filename = e.filename || currentFilename;
|
|
this.message = e.message;
|
|
this.stack = e.stack;
|
|
|
|
if (fileContentMap && filename) {
|
|
var input = fileContentMap.contents[filename];
|
|
var loc = getLocation(e.index, input);
|
|
var line = loc.line;
|
|
var col = loc.column;
|
|
var callLine = e.call && getLocation(e.call, input).line;
|
|
var lines = input ? input.split('\n') : '';
|
|
this.type = e.type || 'Syntax';
|
|
this.filename = filename;
|
|
this.index = e.index;
|
|
this.line = typeof line === 'number' ? line + 1 : null;
|
|
this.column = col;
|
|
|
|
if (!this.line && this.stack) {
|
|
var found = this.stack.match(/(<anonymous>|Function):(\d+):(\d+)/);
|
|
|
|
if (found) {
|
|
if (found[2]) {
|
|
this.line = parseInt(found[2]) - 2;
|
|
}
|
|
|
|
if (found[3]) {
|
|
this.column = parseInt(found[3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.callLine = callLine + 1;
|
|
this.callExtract = lines[callLine];
|
|
this.extract = [lines[this.line - 2], lines[this.line - 1], lines[this.line]];
|
|
}
|
|
};
|
|
|
|
if (typeof Object.create === 'undefined') {
|
|
var F = function F() {};
|
|
|
|
F.prototype = Error.prototype;
|
|
LessError.prototype = new F();
|
|
} else {
|
|
LessError.prototype = Object.create(Error.prototype);
|
|
}
|
|
|
|
LessError.prototype.constructor = LessError;
|
|
/**
|
|
* An overridden version of the default Object.prototype.toString
|
|
* which uses additional information to create a helpful message.
|
|
*
|
|
* @param {Object} options
|
|
* @returns {string}
|
|
*/
|
|
|
|
LessError.prototype.toString = function () {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
var message = '';
|
|
var extract = this.extract || [];
|
|
var error = [];
|
|
|
|
var stylize = function stylize(str) {
|
|
return str;
|
|
};
|
|
|
|
if (options.stylize) {
|
|
var type = typeof options.stylize;
|
|
|
|
if (type !== 'function') {
|
|
throw Error(`options.stylize should be a function, got a ${type}!`);
|
|
}
|
|
|
|
stylize = options.stylize;
|
|
}
|
|
|
|
if (this.line !== null) {
|
|
if (typeof extract[0] === 'string') {
|
|
error.push(stylize(`${this.line - 1} ${extract[0]}`, 'grey'));
|
|
}
|
|
|
|
if (typeof extract[1] === 'string') {
|
|
var errorTxt = `${this.line} `;
|
|
|
|
if (extract[1]) {
|
|
errorTxt += extract[1].slice(0, this.column) + stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') + extract[1].slice(this.column + 1), 'red'), 'inverse');
|
|
}
|
|
|
|
error.push(errorTxt);
|
|
}
|
|
|
|
if (typeof extract[2] === 'string') {
|
|
error.push(stylize(`${this.line + 1} ${extract[2]}`, 'grey'));
|
|
}
|
|
|
|
error = `${error.join('\n') + stylize('', 'reset')}\n`;
|
|
}
|
|
|
|
message += stylize(`${this.type}Error: ${this.message}`, 'red');
|
|
|
|
if (this.filename) {
|
|
message += stylize(' in ', 'red') + this.filename;
|
|
}
|
|
|
|
if (this.line) {
|
|
message += stylize(` on line ${this.line}, column ${this.column + 1}:`, 'grey');
|
|
}
|
|
|
|
message += `\n${error}`;
|
|
|
|
if (this.callLine) {
|
|
message += `${stylize('from ', 'red') + (this.filename || '')}/n`;
|
|
message += `${stylize(this.callLine, 'grey')} ${this.callExtract}/n`;
|
|
}
|
|
|
|
return message;
|
|
};
|
|
|
|
var Selector =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Selector, _Node);
|
|
|
|
function Selector(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Selector);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Selector).call(this));
|
|
_this.extendList = extendList;
|
|
_this.condition = condition;
|
|
_this.evaldCondition = !condition;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.elements = _this.getElements(elements);
|
|
_this.mixinElements_ = undefined;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.setParent(_this.elements, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Selector, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.elements) {
|
|
this.elements = visitor.visitArray(this.elements);
|
|
}
|
|
|
|
if (this.extendList) {
|
|
this.extendList = visitor.visitArray(this.extendList);
|
|
}
|
|
|
|
if (this.condition) {
|
|
this.condition = visitor.visit(this.condition);
|
|
}
|
|
}
|
|
}, {
|
|
key: "createDerived",
|
|
value: function createDerived(elements, extendList, evaldCondition) {
|
|
elements = this.getElements(elements);
|
|
var newSelector = new Selector(elements, extendList || this.extendList, null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
|
|
newSelector.evaldCondition = evaldCondition != null ? evaldCondition : this.evaldCondition;
|
|
newSelector.mediaEmpty = this.mediaEmpty;
|
|
return newSelector;
|
|
}
|
|
}, {
|
|
key: "getElements",
|
|
value: function getElements(els) {
|
|
if (!els) {
|
|
return [new Element('', '&', false, this._index, this._fileInfo)];
|
|
}
|
|
|
|
if (typeof els === 'string') {
|
|
this.parse.parseNode(els, ['selector'], this._index, this._fileInfo, function (err, result) {
|
|
if (err) {
|
|
throw new LessError({
|
|
index: err.index,
|
|
message: err.message
|
|
}, this.parse.imports, this._fileInfo.filename);
|
|
}
|
|
|
|
els = result[0].elements;
|
|
});
|
|
}
|
|
|
|
return els;
|
|
}
|
|
}, {
|
|
key: "createEmptySelectors",
|
|
value: function createEmptySelectors() {
|
|
var el = new Element('', '&', false, this._index, this._fileInfo);
|
|
var sels = [new Selector([el], null, null, this._index, this._fileInfo)];
|
|
sels[0].mediaEmpty = true;
|
|
return sels;
|
|
}
|
|
}, {
|
|
key: "match",
|
|
value: function match(other) {
|
|
var elements = this.elements;
|
|
var len = elements.length;
|
|
var olen;
|
|
var i;
|
|
other = other.mixinElements();
|
|
olen = other.length;
|
|
|
|
if (olen === 0 || len < olen) {
|
|
return 0;
|
|
} else {
|
|
for (i = 0; i < olen; i++) {
|
|
if (elements[i].value !== other[i]) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return olen; // return number of matched elements
|
|
}
|
|
}, {
|
|
key: "mixinElements",
|
|
value: function mixinElements() {
|
|
if (this.mixinElements_) {
|
|
return this.mixinElements_;
|
|
}
|
|
|
|
var elements = this.elements.map(function (v) {
|
|
return v.combinator.value + (v.value.value || v.value);
|
|
}).join('').match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
|
|
|
|
if (elements) {
|
|
if (elements[0] === '&') {
|
|
elements.shift();
|
|
}
|
|
} else {
|
|
elements = [];
|
|
}
|
|
|
|
return this.mixinElements_ = elements;
|
|
}
|
|
}, {
|
|
key: "isJustParentSelector",
|
|
value: function isJustParentSelector() {
|
|
return !this.mediaEmpty && this.elements.length === 1 && this.elements[0].value === '&' && (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var evaldCondition = this.condition && this.condition.eval(context);
|
|
var elements = this.elements;
|
|
var extendList = this.extendList;
|
|
elements = elements && elements.map(function (e) {
|
|
return e.eval(context);
|
|
});
|
|
extendList = extendList && extendList.map(function (extend) {
|
|
return extend.eval(context);
|
|
});
|
|
return this.createDerived(elements, extendList, evaldCondition);
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
var i;
|
|
var element;
|
|
|
|
if ((!context || !context.firstSelector) && this.elements[0].combinator.value === '') {
|
|
output.add(' ', this.fileInfo(), this.getIndex());
|
|
}
|
|
|
|
for (i = 0; i < this.elements.length; i++) {
|
|
element = this.elements[i];
|
|
element.genCSS(context, output);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getIsOutput",
|
|
value: function getIsOutput() {
|
|
return this.evaldCondition;
|
|
}
|
|
}]);
|
|
|
|
return Selector;
|
|
}(Node);
|
|
|
|
Selector.prototype.type = 'Selector';
|
|
|
|
var Value =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Value, _Node);
|
|
|
|
function Value(value) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Value);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Value).call(this));
|
|
|
|
if (!value) {
|
|
throw new Error('Value requires an array argument');
|
|
}
|
|
|
|
if (!Array.isArray(value)) {
|
|
_this.value = [value];
|
|
} else {
|
|
_this.value = value;
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Value, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.value) {
|
|
this.value = visitor.visitArray(this.value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
if (this.value.length === 1) {
|
|
return this.value[0].eval(context);
|
|
} else {
|
|
return new Value(this.value.map(function (v) {
|
|
return v.eval(context);
|
|
}));
|
|
}
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
var i;
|
|
|
|
for (i = 0; i < this.value.length; i++) {
|
|
this.value[i].genCSS(context, output);
|
|
|
|
if (i + 1 < this.value.length) {
|
|
output.add(context && context.compress ? ',' : ', ');
|
|
}
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Value;
|
|
}(Node);
|
|
|
|
Value.prototype.type = 'Value';
|
|
|
|
var Keyword =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Keyword, _Node);
|
|
|
|
function Keyword(value) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Keyword);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Keyword).call(this));
|
|
_this.value = value;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Keyword, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
if (this.value === '%') {
|
|
throw {
|
|
type: 'Syntax',
|
|
message: 'Invalid % without number'
|
|
};
|
|
}
|
|
|
|
output.add(this.value);
|
|
}
|
|
}]);
|
|
|
|
return Keyword;
|
|
}(Node);
|
|
|
|
Keyword.prototype.type = 'Keyword';
|
|
Keyword.True = new Keyword('true');
|
|
Keyword.False = new Keyword('false');
|
|
|
|
var Anonymous =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Anonymous, _Node);
|
|
|
|
function Anonymous(value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Anonymous);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Anonymous).call(this));
|
|
_this.value = value;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.mapLines = mapLines;
|
|
_this.rulesetLike = typeof rulesetLike === 'undefined' ? false : rulesetLike;
|
|
_this.allowRoot = true;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Anonymous, [{
|
|
key: "eval",
|
|
value: function _eval() {
|
|
return new Anonymous(this.value, this._index, this._fileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(other) {
|
|
return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
|
|
}
|
|
}, {
|
|
key: "isRulesetLike",
|
|
value: function isRulesetLike() {
|
|
return this.rulesetLike;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
this.nodeVisible = Boolean(this.value);
|
|
|
|
if (this.nodeVisible) {
|
|
output.add(this.value, this._fileInfo, this._index, this.mapLines);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Anonymous;
|
|
}(Node);
|
|
|
|
Anonymous.prototype.type = 'Anonymous';
|
|
|
|
var MATH = Math$1;
|
|
|
|
var Declaration =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Declaration, _Node);
|
|
|
|
function Declaration(name, value, important, merge, index, currentFileInfo, inline, variable) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Declaration);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Declaration).call(this));
|
|
_this.name = name;
|
|
_this.value = value instanceof Node ? value : new Value([value ? new Anonymous(value) : null]);
|
|
_this.important = important ? ` ${important.trim()}` : '';
|
|
_this.merge = merge;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.inline = inline || false;
|
|
_this.variable = variable !== undefined ? variable : name.charAt && name.charAt(0) === '@';
|
|
_this.allowRoot = true;
|
|
|
|
_this.setParent(_this.value, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Declaration, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(this.name + (context.compress ? ':' : ': '), this.fileInfo(), this.getIndex());
|
|
|
|
try {
|
|
this.value.genCSS(context, output);
|
|
} catch (e) {
|
|
e.index = this._index;
|
|
e.filename = this._fileInfo.filename;
|
|
throw e;
|
|
}
|
|
|
|
output.add(this.important + (this.inline || context.lastRule && context.compress ? '' : ';'), this._fileInfo, this._index);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var mathBypass = false;
|
|
var prevMath;
|
|
var name = this.name;
|
|
var evaldValue;
|
|
var variable = this.variable;
|
|
|
|
if (typeof name !== 'string') {
|
|
// expand 'primitive' name directly to get
|
|
// things faster (~10% for benchmark.less):
|
|
name = name.length === 1 && name[0] instanceof Keyword ? name[0].value : evalName(context, name);
|
|
variable = false; // never treat expanded interpolation as new variable name
|
|
} // @todo remove when parens-division is default
|
|
|
|
|
|
if (name === 'font' && context.math === MATH.ALWAYS) {
|
|
mathBypass = true;
|
|
prevMath = context.math;
|
|
context.math = MATH.PARENS_DIVISION;
|
|
}
|
|
|
|
try {
|
|
context.importantScope.push({});
|
|
evaldValue = this.value.eval(context);
|
|
|
|
if (!this.variable && evaldValue.type === 'DetachedRuleset') {
|
|
throw {
|
|
message: 'Rulesets cannot be evaluated on a property.',
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename
|
|
};
|
|
}
|
|
|
|
var important = this.important;
|
|
var importantResult = context.importantScope.pop();
|
|
|
|
if (!important && importantResult.important) {
|
|
important = importantResult.important;
|
|
}
|
|
|
|
return new Declaration(name, evaldValue, important, this.merge, this.getIndex(), this.fileInfo(), this.inline, variable);
|
|
} catch (e) {
|
|
if (typeof e.index !== 'number') {
|
|
e.index = this.getIndex();
|
|
e.filename = this.fileInfo().filename;
|
|
}
|
|
|
|
throw e;
|
|
} finally {
|
|
if (mathBypass) {
|
|
context.math = prevMath;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "makeImportant",
|
|
value: function makeImportant() {
|
|
return new Declaration(this.name, this.value, '!important', this.merge, this.getIndex(), this.fileInfo(), this.inline);
|
|
}
|
|
}]);
|
|
|
|
return Declaration;
|
|
}(Node);
|
|
|
|
function evalName(context, name) {
|
|
var value = '';
|
|
var i;
|
|
var n = name.length;
|
|
var output = {
|
|
add: function add(s) {
|
|
value += s;
|
|
}
|
|
};
|
|
|
|
for (i = 0; i < n; i++) {
|
|
name[i].eval(context).genCSS(context, output);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
Declaration.prototype.type = 'Declaration';
|
|
|
|
var debugInfo = function debugInfo(context, ctx, lineSeparator) {
|
|
var result = '';
|
|
|
|
if (context.dumpLineNumbers && !context.compress) {
|
|
switch (context.dumpLineNumbers) {
|
|
case 'comments':
|
|
result = debugInfo.asComment(ctx);
|
|
break;
|
|
|
|
case 'mediaquery':
|
|
result = debugInfo.asMediaQuery(ctx);
|
|
break;
|
|
|
|
case 'all':
|
|
result = debugInfo.asComment(ctx) + (lineSeparator || '') + debugInfo.asMediaQuery(ctx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
debugInfo.asComment = function (ctx) {
|
|
return `/* line ${ctx.debugInfo.lineNumber}, ${ctx.debugInfo.fileName} */\n`;
|
|
};
|
|
|
|
debugInfo.asMediaQuery = function (ctx) {
|
|
var filenameWithProtocol = ctx.debugInfo.fileName;
|
|
|
|
if (!/^[a-z]+:\/\//i.test(filenameWithProtocol)) {
|
|
filenameWithProtocol = `file://${filenameWithProtocol}`;
|
|
}
|
|
|
|
return `@media -sass-debug-info{filename{font-family:${filenameWithProtocol.replace(/([.:\/\\])/g, function (a) {
|
|
if (a == '\\') {
|
|
a = '\/';
|
|
}
|
|
|
|
return `\\${a}`;
|
|
})}}line{font-family:\\00003${ctx.debugInfo.lineNumber}}}\n`;
|
|
};
|
|
|
|
var Comment =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Comment, _Node);
|
|
|
|
function Comment(value, isLineComment, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Comment);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Comment).call(this));
|
|
_this.value = value;
|
|
_this.isLineComment = isLineComment;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.allowRoot = true;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Comment, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
if (this.debugInfo) {
|
|
output.add(debugInfo(context, this), this.fileInfo(), this.getIndex());
|
|
}
|
|
|
|
output.add(this.value);
|
|
}
|
|
}, {
|
|
key: "isSilent",
|
|
value: function isSilent(context) {
|
|
var isCompressed = context.compress && this.value[2] !== '!';
|
|
return this.isLineComment || isCompressed;
|
|
}
|
|
}]);
|
|
|
|
return Comment;
|
|
}(Node);
|
|
|
|
Comment.prototype.type = 'Comment';
|
|
|
|
var contexts = {};
|
|
|
|
var copyFromOriginal = function copyFromOriginal(original, destination, propertiesToCopy) {
|
|
if (!original) {
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < propertiesToCopy.length; i++) {
|
|
if (original.hasOwnProperty(propertiesToCopy[i])) {
|
|
destination[propertiesToCopy[i]] = original[propertiesToCopy[i]];
|
|
}
|
|
}
|
|
};
|
|
/*
|
|
parse is used whilst parsing
|
|
*/
|
|
|
|
|
|
var parseCopyProperties = [// options
|
|
'paths', // option - unmodified - paths to search for imports on
|
|
'rewriteUrls', // option - whether to adjust URL's to be relative
|
|
'rootpath', // option - rootpath to append to URL's
|
|
'strictImports', // option -
|
|
'insecure', // option - whether to allow imports from insecure ssl hosts
|
|
'dumpLineNumbers', // option - whether to dump line numbers
|
|
'compress', // option - whether to compress
|
|
'syncImport', // option - whether to import synchronously
|
|
'chunkInput', // option - whether to chunk input. more performant but causes parse issues.
|
|
'mime', // browser only - mime type for sheet import
|
|
'useFileCache', // browser only - whether to use the per file session cache
|
|
// context
|
|
'processImports', // option & context - whether to process imports. if false then imports will not be imported.
|
|
// Used by the import manager to stop multiple import visitors being created.
|
|
'pluginManager' // Used as the plugin manager for the session
|
|
];
|
|
|
|
contexts.Parse = function (options) {
|
|
copyFromOriginal(options, this, parseCopyProperties);
|
|
|
|
if (typeof this.paths === 'string') {
|
|
this.paths = [this.paths];
|
|
}
|
|
};
|
|
|
|
var evalCopyProperties = ['paths', // additional include paths
|
|
'compress', // whether to compress
|
|
'math', // whether math has to be within parenthesis
|
|
'strictUnits', // whether units need to evaluate correctly
|
|
'sourceMap', // whether to output a source map
|
|
'importMultiple', // whether we are currently importing multiple copies
|
|
'urlArgs', // whether to add args into url tokens
|
|
'javascriptEnabled', // option - whether Inline JavaScript is enabled. if undefined, defaults to false
|
|
'pluginManager', // Used as the plugin manager for the session
|
|
'importantScope', // used to bubble up !important statements
|
|
'rewriteUrls' // option - whether to adjust URL's to be relative
|
|
];
|
|
|
|
function isPathRelative(path) {
|
|
return !/^(?:[a-z-]+:|\/|#)/i.test(path);
|
|
}
|
|
|
|
function isPathLocalRelative(path) {
|
|
return path.charAt(0) === '.';
|
|
}
|
|
|
|
contexts.Eval =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function _class(options, frames) {
|
|
_classCallCheck(this, _class);
|
|
|
|
copyFromOriginal(options, this, evalCopyProperties);
|
|
|
|
if (typeof this.paths === 'string') {
|
|
this.paths = [this.paths];
|
|
}
|
|
|
|
this.frames = frames || [];
|
|
this.importantScope = this.importantScope || [];
|
|
this.inCalc = false;
|
|
this.mathOn = true;
|
|
}
|
|
|
|
_createClass(_class, [{
|
|
key: "enterCalc",
|
|
value: function enterCalc() {
|
|
if (!this.calcStack) {
|
|
this.calcStack = [];
|
|
}
|
|
|
|
this.calcStack.push(true);
|
|
this.inCalc = true;
|
|
}
|
|
}, {
|
|
key: "exitCalc",
|
|
value: function exitCalc() {
|
|
this.calcStack.pop();
|
|
|
|
if (!this.calcStack) {
|
|
this.inCalc = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "inParenthesis",
|
|
value: function inParenthesis() {
|
|
if (!this.parensStack) {
|
|
this.parensStack = [];
|
|
}
|
|
|
|
this.parensStack.push(true);
|
|
}
|
|
}, {
|
|
key: "outOfParenthesis",
|
|
value: function outOfParenthesis() {
|
|
this.parensStack.pop();
|
|
}
|
|
}, {
|
|
key: "isMathOn",
|
|
value: function isMathOn(op) {
|
|
if (!this.mathOn) {
|
|
return false;
|
|
}
|
|
|
|
if (op === '/' && this.math !== Math$1.ALWAYS && (!this.parensStack || !this.parensStack.length)) {
|
|
return false;
|
|
}
|
|
|
|
if (this.math > Math$1.PARENS_DIVISION) {
|
|
return this.parensStack && this.parensStack.length;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "pathRequiresRewrite",
|
|
value: function pathRequiresRewrite(path) {
|
|
var isRelative = this.rewriteUrls === RewriteUrls.LOCAL ? isPathLocalRelative : isPathRelative;
|
|
return isRelative(path);
|
|
}
|
|
}, {
|
|
key: "rewritePath",
|
|
value: function rewritePath(path, rootpath) {
|
|
var newPath;
|
|
rootpath = rootpath || '';
|
|
newPath = this.normalizePath(rootpath + path); // If a path was explicit relative and the rootpath was not an absolute path
|
|
// we must ensure that the new path is also explicit relative.
|
|
|
|
if (isPathLocalRelative(path) && isPathRelative(rootpath) && isPathLocalRelative(newPath) === false) {
|
|
newPath = `./${newPath}`;
|
|
}
|
|
|
|
return newPath;
|
|
}
|
|
}, {
|
|
key: "normalizePath",
|
|
value: function normalizePath(path) {
|
|
var segments = path.split('/').reverse();
|
|
var segment;
|
|
path = [];
|
|
|
|
while (segments.length !== 0) {
|
|
segment = segments.pop();
|
|
|
|
switch (segment) {
|
|
case '.':
|
|
break;
|
|
|
|
case '..':
|
|
if (path.length === 0 || path[path.length - 1] === '..') {
|
|
path.push(segment);
|
|
} else {
|
|
path.pop();
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
path.push(segment);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return path.join('/');
|
|
}
|
|
}]);
|
|
|
|
return _class;
|
|
}();
|
|
|
|
function makeRegistry(base) {
|
|
return {
|
|
_data: {},
|
|
add: function add(name, func) {
|
|
// precautionary case conversion, as later querying of
|
|
// the registry by function-caller uses lower case as well.
|
|
name = name.toLowerCase();
|
|
|
|
if (this._data.hasOwnProperty(name)) ;
|
|
|
|
this._data[name] = func;
|
|
},
|
|
addMultiple: function addMultiple(functions) {
|
|
var _this = this;
|
|
|
|
Object.keys(functions).forEach(function (name) {
|
|
_this.add(name, functions[name]);
|
|
});
|
|
},
|
|
get: function get(name) {
|
|
return this._data[name] || base && base.get(name);
|
|
},
|
|
getLocalFunctions: function getLocalFunctions() {
|
|
return this._data;
|
|
},
|
|
inherit: function inherit() {
|
|
return makeRegistry(this);
|
|
},
|
|
create: function create(base) {
|
|
return makeRegistry(base);
|
|
}
|
|
};
|
|
}
|
|
|
|
var functionRegistry = makeRegistry(null);
|
|
|
|
var defaultFunc = {
|
|
eval: function _eval() {
|
|
var v = this.value_;
|
|
var e = this.error_;
|
|
|
|
if (e) {
|
|
throw e;
|
|
}
|
|
|
|
if (v != null) {
|
|
return v ? Keyword.True : Keyword.False;
|
|
}
|
|
},
|
|
value: function value(v) {
|
|
this.value_ = v;
|
|
},
|
|
error: function error(e) {
|
|
this.error_ = e;
|
|
},
|
|
reset: function reset() {
|
|
this.value_ = this.error_ = null;
|
|
}
|
|
};
|
|
|
|
var Ruleset =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Ruleset, _Node);
|
|
|
|
function Ruleset(selectors, rules, strictImports, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Ruleset);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Ruleset).call(this));
|
|
_this.selectors = selectors;
|
|
_this.rules = rules;
|
|
_this._lookups = {};
|
|
_this._variables = null;
|
|
_this._properties = null;
|
|
_this.strictImports = strictImports;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.allowRoot = true;
|
|
|
|
_this.setParent(_this.selectors, _assertThisInitialized(_this));
|
|
|
|
_this.setParent(_this.rules, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Ruleset, [{
|
|
key: "isRulesetLike",
|
|
value: function isRulesetLike() {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.paths) {
|
|
this.paths = visitor.visitArray(this.paths, true);
|
|
} else if (this.selectors) {
|
|
this.selectors = visitor.visitArray(this.selectors);
|
|
}
|
|
|
|
if (this.rules && this.rules.length) {
|
|
this.rules = visitor.visitArray(this.rules);
|
|
}
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var selectors;
|
|
var selCnt;
|
|
var selector;
|
|
var i;
|
|
var hasVariable;
|
|
var hasOnePassingSelector = false;
|
|
|
|
if (this.selectors && (selCnt = this.selectors.length)) {
|
|
selectors = new Array(selCnt);
|
|
defaultFunc.error({
|
|
type: 'Syntax',
|
|
message: 'it is currently only allowed in parametric mixin guards,'
|
|
});
|
|
|
|
for (i = 0; i < selCnt; i++) {
|
|
selector = this.selectors[i].eval(context);
|
|
|
|
for (var j = 0; j < selector.elements.length; j++) {
|
|
if (selector.elements[j].isVariable) {
|
|
hasVariable = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
selectors[i] = selector;
|
|
|
|
if (selector.evaldCondition) {
|
|
hasOnePassingSelector = true;
|
|
}
|
|
}
|
|
|
|
if (hasVariable) {
|
|
var toParseSelectors = new Array(selCnt);
|
|
|
|
for (i = 0; i < selCnt; i++) {
|
|
selector = selectors[i];
|
|
toParseSelectors[i] = selector.toCSS(context);
|
|
}
|
|
|
|
this.parse.parseNode(toParseSelectors.join(','), ["selectors"], selectors[0].getIndex(), selectors[0].fileInfo(), function (err, result) {
|
|
if (result) {
|
|
selectors = flattenArray(result);
|
|
}
|
|
});
|
|
}
|
|
|
|
defaultFunc.reset();
|
|
} else {
|
|
hasOnePassingSelector = true;
|
|
}
|
|
|
|
var rules = this.rules ? copyArray(this.rules) : null;
|
|
var ruleset = new Ruleset(selectors, rules, this.strictImports, this.visibilityInfo());
|
|
var rule;
|
|
var subRule;
|
|
ruleset.originalRuleset = this;
|
|
ruleset.root = this.root;
|
|
ruleset.firstRoot = this.firstRoot;
|
|
ruleset.allowImports = this.allowImports;
|
|
|
|
if (this.debugInfo) {
|
|
ruleset.debugInfo = this.debugInfo;
|
|
}
|
|
|
|
if (!hasOnePassingSelector) {
|
|
rules.length = 0;
|
|
} // inherit a function registry from the frames stack when possible;
|
|
// otherwise from the global registry
|
|
|
|
|
|
ruleset.functionRegistry = function (frames) {
|
|
var i = 0;
|
|
var n = frames.length;
|
|
var found;
|
|
|
|
for (; i !== n; ++i) {
|
|
found = frames[i].functionRegistry;
|
|
|
|
if (found) {
|
|
return found;
|
|
}
|
|
}
|
|
|
|
return functionRegistry;
|
|
}(context.frames).inherit(); // push the current ruleset to the frames stack
|
|
|
|
|
|
var ctxFrames = context.frames;
|
|
ctxFrames.unshift(ruleset); // currrent selectors
|
|
|
|
var ctxSelectors = context.selectors;
|
|
|
|
if (!ctxSelectors) {
|
|
context.selectors = ctxSelectors = [];
|
|
}
|
|
|
|
ctxSelectors.unshift(this.selectors); // Evaluate imports
|
|
|
|
if (ruleset.root || ruleset.allowImports || !ruleset.strictImports) {
|
|
ruleset.evalImports(context);
|
|
} // Store the frames around mixin definitions,
|
|
// so they can be evaluated like closures when the time comes.
|
|
|
|
|
|
var rsRules = ruleset.rules;
|
|
|
|
for (i = 0; rule = rsRules[i]; i++) {
|
|
if (rule.evalFirst) {
|
|
rsRules[i] = rule.eval(context);
|
|
}
|
|
}
|
|
|
|
var mediaBlockCount = context.mediaBlocks && context.mediaBlocks.length || 0; // Evaluate mixin calls.
|
|
|
|
for (i = 0; rule = rsRules[i]; i++) {
|
|
if (rule.type === 'MixinCall') {
|
|
/* jshint loopfunc:true */
|
|
rules = rule.eval(context).filter(function (r) {
|
|
if (r instanceof Declaration && r.variable) {
|
|
// do not pollute the scope if the variable is
|
|
// already there. consider returning false here
|
|
// but we need a way to "return" variable from mixins
|
|
return !ruleset.variable(r.name);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
rsRules.splice.apply(rsRules, _toConsumableArray([i, 1].concat(rules)));
|
|
i += rules.length - 1;
|
|
ruleset.resetCache();
|
|
} else if (rule.type === 'VariableCall') {
|
|
/* jshint loopfunc:true */
|
|
rules = rule.eval(context).rules.filter(function (r) {
|
|
if (r instanceof Declaration && r.variable) {
|
|
// do not pollute the scope at all
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
rsRules.splice.apply(rsRules, _toConsumableArray([i, 1].concat(rules)));
|
|
i += rules.length - 1;
|
|
ruleset.resetCache();
|
|
}
|
|
} // Evaluate everything else
|
|
|
|
|
|
for (i = 0; rule = rsRules[i]; i++) {
|
|
if (!rule.evalFirst) {
|
|
rsRules[i] = rule = rule.eval ? rule.eval(context) : rule;
|
|
}
|
|
} // Evaluate everything else
|
|
|
|
|
|
for (i = 0; rule = rsRules[i]; i++) {
|
|
// for rulesets, check if it is a css guard and can be removed
|
|
if (rule instanceof Ruleset && rule.selectors && rule.selectors.length === 1) {
|
|
// check if it can be folded in (e.g. & where)
|
|
if (rule.selectors[0] && rule.selectors[0].isJustParentSelector()) {
|
|
rsRules.splice(i--, 1);
|
|
|
|
for (var j = 0; subRule = rule.rules[j]; j++) {
|
|
if (subRule instanceof Node) {
|
|
subRule.copyVisibilityInfo(rule.visibilityInfo());
|
|
|
|
if (!(subRule instanceof Declaration) || !subRule.variable) {
|
|
rsRules.splice(++i, 0, subRule);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // Pop the stack
|
|
|
|
|
|
ctxFrames.shift();
|
|
ctxSelectors.shift();
|
|
|
|
if (context.mediaBlocks) {
|
|
for (i = mediaBlockCount; i < context.mediaBlocks.length; i++) {
|
|
context.mediaBlocks[i].bubbleSelectors(selectors);
|
|
}
|
|
}
|
|
|
|
return ruleset;
|
|
}
|
|
}, {
|
|
key: "evalImports",
|
|
value: function evalImports(context) {
|
|
var rules = this.rules;
|
|
var i;
|
|
var importRules;
|
|
|
|
if (!rules) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < rules.length; i++) {
|
|
if (rules[i].type === 'Import') {
|
|
importRules = rules[i].eval(context);
|
|
|
|
if (importRules && (importRules.length || importRules.length === 0)) {
|
|
rules.splice.apply(rules, _toConsumableArray([i, 1].concat(importRules)));
|
|
i += importRules.length - 1;
|
|
} else {
|
|
rules.splice(i, 1, importRules);
|
|
}
|
|
|
|
this.resetCache();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "makeImportant",
|
|
value: function makeImportant() {
|
|
var result = new Ruleset(this.selectors, this.rules.map(function (r) {
|
|
if (r.makeImportant) {
|
|
return r.makeImportant();
|
|
} else {
|
|
return r;
|
|
}
|
|
}), this.strictImports, this.visibilityInfo());
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "matchArgs",
|
|
value: function matchArgs(args) {
|
|
return !args || args.length === 0;
|
|
} // lets you call a css selector with a guard
|
|
|
|
}, {
|
|
key: "matchCondition",
|
|
value: function matchCondition(args, context) {
|
|
var lastSelector = this.selectors[this.selectors.length - 1];
|
|
|
|
if (!lastSelector.evaldCondition) {
|
|
return false;
|
|
}
|
|
|
|
if (lastSelector.condition && !lastSelector.condition.eval(new contexts.Eval(context, context.frames))) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "resetCache",
|
|
value: function resetCache() {
|
|
this._rulesets = null;
|
|
this._variables = null;
|
|
this._properties = null;
|
|
this._lookups = {};
|
|
}
|
|
}, {
|
|
key: "variables",
|
|
value: function variables() {
|
|
if (!this._variables) {
|
|
this._variables = !this.rules ? {} : this.rules.reduce(function (hash, r) {
|
|
if (r instanceof Declaration && r.variable === true) {
|
|
hash[r.name] = r;
|
|
} // when evaluating variables in an import statement, imports have not been eval'd
|
|
// so we need to go inside import statements.
|
|
// guard against root being a string (in the case of inlined less)
|
|
|
|
|
|
if (r.type === 'Import' && r.root && r.root.variables) {
|
|
var vars = r.root.variables();
|
|
|
|
for (var name in vars) {
|
|
if (vars.hasOwnProperty(name)) {
|
|
hash[name] = r.root.variable(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hash;
|
|
}, {});
|
|
}
|
|
|
|
return this._variables;
|
|
}
|
|
}, {
|
|
key: "properties",
|
|
value: function properties() {
|
|
if (!this._properties) {
|
|
this._properties = !this.rules ? {} : this.rules.reduce(function (hash, r) {
|
|
if (r instanceof Declaration && r.variable !== true) {
|
|
var name = r.name.length === 1 && r.name[0] instanceof Keyword ? r.name[0].value : r.name; // Properties don't overwrite as they can merge
|
|
|
|
if (!hash[`$${name}`]) {
|
|
hash[`$${name}`] = [r];
|
|
} else {
|
|
hash[`$${name}`].push(r);
|
|
}
|
|
}
|
|
|
|
return hash;
|
|
}, {});
|
|
}
|
|
|
|
return this._properties;
|
|
}
|
|
}, {
|
|
key: "variable",
|
|
value: function variable(name) {
|
|
var decl = this.variables()[name];
|
|
|
|
if (decl) {
|
|
return this.parseValue(decl);
|
|
}
|
|
}
|
|
}, {
|
|
key: "property",
|
|
value: function property(name) {
|
|
var decl = this.properties()[name];
|
|
|
|
if (decl) {
|
|
return this.parseValue(decl);
|
|
}
|
|
}
|
|
}, {
|
|
key: "lastDeclaration",
|
|
value: function lastDeclaration() {
|
|
for (var i = this.rules.length; i > 0; i--) {
|
|
var decl = this.rules[i - 1];
|
|
|
|
if (decl instanceof Declaration) {
|
|
return this.parseValue(decl);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "parseValue",
|
|
value: function parseValue(toParse) {
|
|
var self = this;
|
|
|
|
function transformDeclaration(decl) {
|
|
if (decl.value instanceof Anonymous && !decl.parsed) {
|
|
if (typeof decl.value.value === 'string') {
|
|
this.parse.parseNode(decl.value.value, ['value', 'important'], decl.value.getIndex(), decl.fileInfo(), function (err, result) {
|
|
if (err) {
|
|
decl.parsed = true;
|
|
}
|
|
|
|
if (result) {
|
|
decl.value = result[0];
|
|
decl.important = result[1] || '';
|
|
decl.parsed = true;
|
|
}
|
|
});
|
|
} else {
|
|
decl.parsed = true;
|
|
}
|
|
|
|
return decl;
|
|
} else {
|
|
return decl;
|
|
}
|
|
}
|
|
|
|
if (!Array.isArray(toParse)) {
|
|
return transformDeclaration.call(self, toParse);
|
|
} else {
|
|
var nodes = [];
|
|
toParse.forEach(function (n) {
|
|
nodes.push(transformDeclaration.call(self, n));
|
|
});
|
|
return nodes;
|
|
}
|
|
}
|
|
}, {
|
|
key: "rulesets",
|
|
value: function rulesets() {
|
|
if (!this.rules) {
|
|
return [];
|
|
}
|
|
|
|
var filtRules = [];
|
|
var rules = this.rules;
|
|
var i;
|
|
var rule;
|
|
|
|
for (i = 0; rule = rules[i]; i++) {
|
|
if (rule.isRuleset) {
|
|
filtRules.push(rule);
|
|
}
|
|
}
|
|
|
|
return filtRules;
|
|
}
|
|
}, {
|
|
key: "prependRule",
|
|
value: function prependRule(rule) {
|
|
var rules = this.rules;
|
|
|
|
if (rules) {
|
|
rules.unshift(rule);
|
|
} else {
|
|
this.rules = [rule];
|
|
}
|
|
|
|
this.setParent(rule, this);
|
|
}
|
|
}, {
|
|
key: "find",
|
|
value: function find(selector) {
|
|
var self = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
|
|
var filter = arguments.length > 2 ? arguments[2] : undefined;
|
|
var rules = [];
|
|
var match;
|
|
var foundMixins;
|
|
var key = selector.toCSS();
|
|
|
|
if (key in this._lookups) {
|
|
return this._lookups[key];
|
|
}
|
|
|
|
this.rulesets().forEach(function (rule) {
|
|
if (rule !== self) {
|
|
for (var j = 0; j < rule.selectors.length; j++) {
|
|
match = selector.match(rule.selectors[j]);
|
|
|
|
if (match) {
|
|
if (selector.elements.length > match) {
|
|
if (!filter || filter(rule)) {
|
|
foundMixins = rule.find(new Selector(selector.elements.slice(match)), self, filter);
|
|
|
|
for (var i = 0; i < foundMixins.length; ++i) {
|
|
foundMixins[i].path.push(rule);
|
|
}
|
|
|
|
Array.prototype.push.apply(rules, foundMixins);
|
|
}
|
|
} else {
|
|
rules.push({
|
|
rule,
|
|
path: []
|
|
});
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
this._lookups[key] = rules;
|
|
return rules;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
var i;
|
|
var j;
|
|
var charsetRuleNodes = [];
|
|
var ruleNodes = [];
|
|
var // Line number debugging
|
|
debugInfo$1;
|
|
var rule;
|
|
var path;
|
|
context.tabLevel = context.tabLevel || 0;
|
|
|
|
if (!this.root) {
|
|
context.tabLevel++;
|
|
}
|
|
|
|
var tabRuleStr = context.compress ? '' : Array(context.tabLevel + 1).join(' ');
|
|
var tabSetStr = context.compress ? '' : Array(context.tabLevel).join(' ');
|
|
var sep;
|
|
var charsetNodeIndex = 0;
|
|
var importNodeIndex = 0;
|
|
|
|
for (i = 0; rule = this.rules[i]; i++) {
|
|
if (rule instanceof Comment) {
|
|
if (importNodeIndex === i) {
|
|
importNodeIndex++;
|
|
}
|
|
|
|
ruleNodes.push(rule);
|
|
} else if (rule.isCharset && rule.isCharset()) {
|
|
ruleNodes.splice(charsetNodeIndex, 0, rule);
|
|
charsetNodeIndex++;
|
|
importNodeIndex++;
|
|
} else if (rule.type === 'Import') {
|
|
ruleNodes.splice(importNodeIndex, 0, rule);
|
|
importNodeIndex++;
|
|
} else {
|
|
ruleNodes.push(rule);
|
|
}
|
|
}
|
|
|
|
ruleNodes = charsetRuleNodes.concat(ruleNodes); // If this is the root node, we don't render
|
|
// a selector, or {}.
|
|
|
|
if (!this.root) {
|
|
debugInfo$1 = debugInfo(context, this, tabSetStr);
|
|
|
|
if (debugInfo$1) {
|
|
output.add(debugInfo$1);
|
|
output.add(tabSetStr);
|
|
}
|
|
|
|
var paths = this.paths;
|
|
var pathCnt = paths.length;
|
|
var pathSubCnt;
|
|
sep = context.compress ? ',' : `,\n${tabSetStr}`;
|
|
|
|
for (i = 0; i < pathCnt; i++) {
|
|
path = paths[i];
|
|
|
|
if (!(pathSubCnt = path.length)) {
|
|
continue;
|
|
}
|
|
|
|
if (i > 0) {
|
|
output.add(sep);
|
|
}
|
|
|
|
context.firstSelector = true;
|
|
path[0].genCSS(context, output);
|
|
context.firstSelector = false;
|
|
|
|
for (j = 1; j < pathSubCnt; j++) {
|
|
path[j].genCSS(context, output);
|
|
}
|
|
}
|
|
|
|
output.add((context.compress ? '{' : ' {\n') + tabRuleStr);
|
|
} // Compile rules and rulesets
|
|
|
|
|
|
for (i = 0; rule = ruleNodes[i]; i++) {
|
|
if (i + 1 === ruleNodes.length) {
|
|
context.lastRule = true;
|
|
}
|
|
|
|
var currentLastRule = context.lastRule;
|
|
|
|
if (rule.isRulesetLike(rule)) {
|
|
context.lastRule = false;
|
|
}
|
|
|
|
if (rule.genCSS) {
|
|
rule.genCSS(context, output);
|
|
} else if (rule.value) {
|
|
output.add(rule.value.toString());
|
|
}
|
|
|
|
context.lastRule = currentLastRule;
|
|
|
|
if (!context.lastRule && rule.isVisible()) {
|
|
output.add(context.compress ? '' : `\n${tabRuleStr}`);
|
|
} else {
|
|
context.lastRule = false;
|
|
}
|
|
}
|
|
|
|
if (!this.root) {
|
|
output.add(context.compress ? '}' : `\n${tabSetStr}}`);
|
|
context.tabLevel--;
|
|
}
|
|
|
|
if (!output.isEmpty() && !context.compress && this.firstRoot) {
|
|
output.add('\n');
|
|
}
|
|
}
|
|
}, {
|
|
key: "joinSelectors",
|
|
value: function joinSelectors(paths, context, selectors) {
|
|
for (var s = 0; s < selectors.length; s++) {
|
|
this.joinSelector(paths, context, selectors[s]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "joinSelector",
|
|
value: function joinSelector(paths, context, selector) {
|
|
function createParenthesis(elementsToPak, originalElement) {
|
|
var replacementParen;
|
|
var j;
|
|
|
|
if (elementsToPak.length === 0) {
|
|
replacementParen = new Paren(elementsToPak[0]);
|
|
} else {
|
|
var insideParent = new Array(elementsToPak.length);
|
|
|
|
for (j = 0; j < elementsToPak.length; j++) {
|
|
insideParent[j] = new Element(null, elementsToPak[j], originalElement.isVariable, originalElement._index, originalElement._fileInfo);
|
|
}
|
|
|
|
replacementParen = new Paren(new Selector(insideParent));
|
|
}
|
|
|
|
return replacementParen;
|
|
}
|
|
|
|
function createSelector(containedElement, originalElement) {
|
|
var element;
|
|
var selector;
|
|
element = new Element(null, containedElement, originalElement.isVariable, originalElement._index, originalElement._fileInfo);
|
|
selector = new Selector([element]);
|
|
return selector;
|
|
} // joins selector path from `beginningPath` with selector path in `addPath`
|
|
// `replacedElement` contains element that is being replaced by `addPath`
|
|
// returns concatenated path
|
|
|
|
|
|
function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {
|
|
var newSelectorPath;
|
|
var lastSelector;
|
|
var newJoinedSelector; // our new selector path
|
|
|
|
newSelectorPath = []; // construct the joined selector - if & is the first thing this will be empty,
|
|
// if not newJoinedSelector will be the last set of elements in the selector
|
|
|
|
if (beginningPath.length > 0) {
|
|
newSelectorPath = copyArray(beginningPath);
|
|
lastSelector = newSelectorPath.pop();
|
|
newJoinedSelector = originalSelector.createDerived(copyArray(lastSelector.elements));
|
|
} else {
|
|
newJoinedSelector = originalSelector.createDerived([]);
|
|
}
|
|
|
|
if (addPath.length > 0) {
|
|
// /deep/ is a CSS4 selector - (removed, so should deprecate)
|
|
// that is valid without anything in front of it
|
|
// so if the & does not have a combinator that is "" or " " then
|
|
// and there is a combinator on the parent, then grab that.
|
|
// this also allows + a { & .b { .a & { ... though not sure why you would want to do that
|
|
var combinator = replacedElement.combinator;
|
|
var parentEl = addPath[0].elements[0];
|
|
|
|
if (combinator.emptyOrWhitespace && !parentEl.combinator.emptyOrWhitespace) {
|
|
combinator = parentEl.combinator;
|
|
} // join the elements so far with the first part of the parent
|
|
|
|
|
|
newJoinedSelector.elements.push(new Element(combinator, parentEl.value, replacedElement.isVariable, replacedElement._index, replacedElement._fileInfo));
|
|
newJoinedSelector.elements = newJoinedSelector.elements.concat(addPath[0].elements.slice(1));
|
|
} // now add the joined selector - but only if it is not empty
|
|
|
|
|
|
if (newJoinedSelector.elements.length !== 0) {
|
|
newSelectorPath.push(newJoinedSelector);
|
|
} // put together the parent selectors after the join (e.g. the rest of the parent)
|
|
|
|
|
|
if (addPath.length > 1) {
|
|
var restOfPath = addPath.slice(1);
|
|
restOfPath = restOfPath.map(function (selector) {
|
|
return selector.createDerived(selector.elements, []);
|
|
});
|
|
newSelectorPath = newSelectorPath.concat(restOfPath);
|
|
}
|
|
|
|
return newSelectorPath;
|
|
} // joins selector path from `beginningPath` with every selector path in `addPaths` array
|
|
// `replacedElement` contains element that is being replaced by `addPath`
|
|
// returns array with all concatenated paths
|
|
|
|
|
|
function addAllReplacementsIntoPath(beginningPath, addPaths, replacedElement, originalSelector, result) {
|
|
var j;
|
|
|
|
for (j = 0; j < beginningPath.length; j++) {
|
|
var newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
|
|
result.push(newSelectorPath);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function mergeElementsOnToSelectors(elements, selectors) {
|
|
var i;
|
|
var sel;
|
|
|
|
if (elements.length === 0) {
|
|
return;
|
|
}
|
|
|
|
if (selectors.length === 0) {
|
|
selectors.push([new Selector(elements)]);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; sel = selectors[i]; i++) {
|
|
// if the previous thing in sel is a parent this needs to join on to it
|
|
if (sel.length > 0) {
|
|
sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));
|
|
} else {
|
|
sel.push(new Selector(elements));
|
|
}
|
|
}
|
|
} // replace all parent selectors inside `inSelector` by content of `context` array
|
|
// resulting selectors are returned inside `paths` array
|
|
// returns true if `inSelector` contained at least one parent selector
|
|
|
|
|
|
function replaceParentSelector(paths, context, inSelector) {
|
|
// The paths are [[Selector]]
|
|
// The first list is a list of comma separated selectors
|
|
// The inner list is a list of inheritance separated selectors
|
|
// e.g.
|
|
// .a, .b {
|
|
// .c {
|
|
// }
|
|
// }
|
|
// == [[.a] [.c]] [[.b] [.c]]
|
|
//
|
|
var i;
|
|
var j;
|
|
var k;
|
|
var currentElements;
|
|
var newSelectors;
|
|
var selectorsMultiplied;
|
|
var sel;
|
|
var el;
|
|
var hadParentSelector = false;
|
|
var length;
|
|
var lastSelector;
|
|
|
|
function findNestedSelector(element) {
|
|
var maybeSelector;
|
|
|
|
if (!(element.value instanceof Paren)) {
|
|
return null;
|
|
}
|
|
|
|
maybeSelector = element.value.value;
|
|
|
|
if (!(maybeSelector instanceof Selector)) {
|
|
return null;
|
|
}
|
|
|
|
return maybeSelector;
|
|
} // the elements from the current selector so far
|
|
|
|
|
|
currentElements = []; // the current list of new selectors to add to the path.
|
|
// We will build it up. We initiate it with one empty selector as we "multiply" the new selectors
|
|
// by the parents
|
|
|
|
newSelectors = [[]];
|
|
|
|
for (i = 0; el = inSelector.elements[i]; i++) {
|
|
// non parent reference elements just get added
|
|
if (el.value !== '&') {
|
|
var nestedSelector = findNestedSelector(el);
|
|
|
|
if (nestedSelector != null) {
|
|
// merge the current list of non parent selector elements
|
|
// on to the current list of selectors to add
|
|
mergeElementsOnToSelectors(currentElements, newSelectors);
|
|
var nestedPaths = [];
|
|
var replaced = void 0;
|
|
var replacedNewSelectors = [];
|
|
replaced = replaceParentSelector(nestedPaths, context, nestedSelector);
|
|
hadParentSelector = hadParentSelector || replaced; // the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors
|
|
|
|
for (k = 0; k < nestedPaths.length; k++) {
|
|
var replacementSelector = createSelector(createParenthesis(nestedPaths[k], el), el);
|
|
addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);
|
|
}
|
|
|
|
newSelectors = replacedNewSelectors;
|
|
currentElements = [];
|
|
} else {
|
|
currentElements.push(el);
|
|
}
|
|
} else {
|
|
hadParentSelector = true; // the new list of selectors to add
|
|
|
|
selectorsMultiplied = []; // merge the current list of non parent selector elements
|
|
// on to the current list of selectors to add
|
|
|
|
mergeElementsOnToSelectors(currentElements, newSelectors); // loop through our current selectors
|
|
|
|
for (j = 0; j < newSelectors.length; j++) {
|
|
sel = newSelectors[j]; // if we don't have any parent paths, the & might be in a mixin so that it can be used
|
|
// whether there are parents or not
|
|
|
|
if (context.length === 0) {
|
|
// the combinator used on el should now be applied to the next element instead so that
|
|
// it is not lost
|
|
if (sel.length > 0) {
|
|
sel[0].elements.push(new Element(el.combinator, '', el.isVariable, el._index, el._fileInfo));
|
|
}
|
|
|
|
selectorsMultiplied.push(sel);
|
|
} else {
|
|
// and the parent selectors
|
|
for (k = 0; k < context.length; k++) {
|
|
// We need to put the current selectors
|
|
// then join the last selector's elements on to the parents selectors
|
|
var newSelectorPath = addReplacementIntoPath(sel, context[k], el, inSelector); // add that to our new set of selectors
|
|
|
|
selectorsMultiplied.push(newSelectorPath);
|
|
}
|
|
}
|
|
} // our new selectors has been multiplied, so reset the state
|
|
|
|
|
|
newSelectors = selectorsMultiplied;
|
|
currentElements = [];
|
|
}
|
|
} // if we have any elements left over (e.g. .a& .b == .b)
|
|
// add them on to all the current selectors
|
|
|
|
|
|
mergeElementsOnToSelectors(currentElements, newSelectors);
|
|
|
|
for (i = 0; i < newSelectors.length; i++) {
|
|
length = newSelectors[i].length;
|
|
|
|
if (length > 0) {
|
|
paths.push(newSelectors[i]);
|
|
lastSelector = newSelectors[i][length - 1];
|
|
newSelectors[i][length - 1] = lastSelector.createDerived(lastSelector.elements, inSelector.extendList);
|
|
}
|
|
}
|
|
|
|
return hadParentSelector;
|
|
}
|
|
|
|
function deriveSelector(visibilityInfo, deriveFrom) {
|
|
var newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);
|
|
newSelector.copyVisibilityInfo(visibilityInfo);
|
|
return newSelector;
|
|
} // joinSelector code follows
|
|
|
|
|
|
var i;
|
|
var newPaths;
|
|
var hadParentSelector;
|
|
newPaths = [];
|
|
hadParentSelector = replaceParentSelector(newPaths, context, selector);
|
|
|
|
if (!hadParentSelector) {
|
|
if (context.length > 0) {
|
|
newPaths = [];
|
|
|
|
for (i = 0; i < context.length; i++) {
|
|
var concatenated = context[i].map(deriveSelector.bind(this, selector.visibilityInfo()));
|
|
concatenated.push(selector);
|
|
newPaths.push(concatenated);
|
|
}
|
|
} else {
|
|
newPaths = [[selector]];
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < newPaths.length; i++) {
|
|
paths.push(newPaths[i]);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Ruleset;
|
|
}(Node);
|
|
|
|
Ruleset.prototype.type = 'Ruleset';
|
|
Ruleset.prototype.isRuleset = true;
|
|
|
|
var AtRule =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(AtRule, _Node);
|
|
|
|
function AtRule(name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AtRule);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AtRule).call(this));
|
|
var i;
|
|
_this.name = name;
|
|
_this.value = value instanceof Node ? value : value ? new Anonymous(value) : value;
|
|
|
|
if (rules) {
|
|
if (Array.isArray(rules)) {
|
|
_this.rules = rules;
|
|
} else {
|
|
_this.rules = [rules];
|
|
_this.rules[0].selectors = new Selector([], null, null, index, currentFileInfo).createEmptySelectors();
|
|
}
|
|
|
|
for (i = 0; i < _this.rules.length; i++) {
|
|
_this.rules[i].allowImports = true;
|
|
}
|
|
|
|
_this.setParent(_this.rules, _assertThisInitialized(_this));
|
|
}
|
|
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.debugInfo = debugInfo;
|
|
_this.isRooted = isRooted || false;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.allowRoot = true;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AtRule, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
var value = this.value;
|
|
var rules = this.rules;
|
|
|
|
if (rules) {
|
|
this.rules = visitor.visitArray(rules);
|
|
}
|
|
|
|
if (value) {
|
|
this.value = visitor.visit(value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isRulesetLike",
|
|
value: function isRulesetLike() {
|
|
return this.rules || !this.isCharset();
|
|
}
|
|
}, {
|
|
key: "isCharset",
|
|
value: function isCharset() {
|
|
return '@charset' === this.name;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
var value = this.value;
|
|
var rules = this.rules;
|
|
output.add(this.name, this.fileInfo(), this.getIndex());
|
|
|
|
if (value) {
|
|
output.add(' ');
|
|
value.genCSS(context, output);
|
|
}
|
|
|
|
if (rules) {
|
|
this.outputRuleset(context, output, rules);
|
|
} else {
|
|
output.add(';');
|
|
}
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var mediaPathBackup;
|
|
var mediaBlocksBackup;
|
|
var value = this.value;
|
|
var rules = this.rules; // media stored inside other atrule should not bubble over it
|
|
// backpup media bubbling information
|
|
|
|
mediaPathBackup = context.mediaPath;
|
|
mediaBlocksBackup = context.mediaBlocks; // deleted media bubbling information
|
|
|
|
context.mediaPath = [];
|
|
context.mediaBlocks = [];
|
|
|
|
if (value) {
|
|
value = value.eval(context);
|
|
}
|
|
|
|
if (rules) {
|
|
// assuming that there is only one rule at this point - that is how parser constructs the rule
|
|
rules = [rules[0].eval(context)];
|
|
rules[0].root = true;
|
|
} // restore media bubbling information
|
|
|
|
|
|
context.mediaPath = mediaPathBackup;
|
|
context.mediaBlocks = mediaBlocksBackup;
|
|
return new AtRule(this.name, value, rules, this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "variable",
|
|
value: function variable(name) {
|
|
if (this.rules) {
|
|
// assuming that there is only one rule at this point - that is how parser constructs the rule
|
|
return Ruleset.prototype.variable.call(this.rules[0], name);
|
|
}
|
|
}
|
|
}, {
|
|
key: "find",
|
|
value: function find() {
|
|
if (this.rules) {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
// assuming that there is only one rule at this point - that is how parser constructs the rule
|
|
return Ruleset.prototype.find.apply(this.rules[0], args);
|
|
}
|
|
}
|
|
}, {
|
|
key: "rulesets",
|
|
value: function rulesets() {
|
|
if (this.rules) {
|
|
// assuming that there is only one rule at this point - that is how parser constructs the rule
|
|
return Ruleset.prototype.rulesets.apply(this.rules[0]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "outputRuleset",
|
|
value: function outputRuleset(context, output, rules) {
|
|
var ruleCnt = rules.length;
|
|
var i;
|
|
context.tabLevel = (context.tabLevel | 0) + 1; // Compressed
|
|
|
|
if (context.compress) {
|
|
output.add('{');
|
|
|
|
for (i = 0; i < ruleCnt; i++) {
|
|
rules[i].genCSS(context, output);
|
|
}
|
|
|
|
output.add('}');
|
|
context.tabLevel--;
|
|
return;
|
|
} // Non-compressed
|
|
|
|
|
|
var tabSetStr = `\n${Array(context.tabLevel).join(' ')}`;
|
|
var tabRuleStr = `${tabSetStr} `;
|
|
|
|
if (!ruleCnt) {
|
|
output.add(` {${tabSetStr}}`);
|
|
} else {
|
|
output.add(` {${tabRuleStr}`);
|
|
rules[0].genCSS(context, output);
|
|
|
|
for (i = 1; i < ruleCnt; i++) {
|
|
output.add(tabRuleStr);
|
|
rules[i].genCSS(context, output);
|
|
}
|
|
|
|
output.add(`${tabSetStr}}`);
|
|
}
|
|
|
|
context.tabLevel--;
|
|
}
|
|
}]);
|
|
|
|
return AtRule;
|
|
}(Node);
|
|
|
|
AtRule.prototype.type = 'AtRule';
|
|
|
|
var DetachedRuleset =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(DetachedRuleset, _Node);
|
|
|
|
function DetachedRuleset(ruleset, frames) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DetachedRuleset);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(DetachedRuleset).call(this));
|
|
_this.ruleset = ruleset;
|
|
_this.frames = frames;
|
|
|
|
_this.setParent(_this.ruleset, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DetachedRuleset, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.ruleset = visitor.visit(this.ruleset);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var frames = this.frames || copyArray(context.frames);
|
|
return new DetachedRuleset(this.ruleset, frames);
|
|
}
|
|
}, {
|
|
key: "callEval",
|
|
value: function callEval(context) {
|
|
return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
|
|
}
|
|
}]);
|
|
|
|
return DetachedRuleset;
|
|
}(Node);
|
|
|
|
DetachedRuleset.prototype.type = 'DetachedRuleset';
|
|
DetachedRuleset.prototype.evalFirst = true;
|
|
|
|
var Unit =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Unit, _Node);
|
|
|
|
function Unit(numerator, denominator, backupUnit) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Unit);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Unit).call(this));
|
|
_this.numerator = numerator ? copyArray(numerator).sort() : [];
|
|
_this.denominator = denominator ? copyArray(denominator).sort() : [];
|
|
|
|
if (backupUnit) {
|
|
_this.backupUnit = backupUnit;
|
|
} else if (numerator && numerator.length) {
|
|
_this.backupUnit = numerator[0];
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Unit, [{
|
|
key: "clone",
|
|
value: function clone() {
|
|
return new Unit(copyArray(this.numerator), copyArray(this.denominator), this.backupUnit);
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
// Dimension checks the unit is singular and throws an error if in strict math mode.
|
|
var strictUnits = context && context.strictUnits;
|
|
|
|
if (this.numerator.length === 1) {
|
|
output.add(this.numerator[0]); // the ideal situation
|
|
} else if (!strictUnits && this.backupUnit) {
|
|
output.add(this.backupUnit);
|
|
} else if (!strictUnits && this.denominator.length) {
|
|
output.add(this.denominator[0]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
var i;
|
|
var returnStr = this.numerator.join('*');
|
|
|
|
for (i = 0; i < this.denominator.length; i++) {
|
|
returnStr += `/${this.denominator[i]}`;
|
|
}
|
|
|
|
return returnStr;
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(other) {
|
|
return this.is(other.toString()) ? 0 : undefined;
|
|
}
|
|
}, {
|
|
key: "is",
|
|
value: function is(unitString) {
|
|
return this.toString().toUpperCase() === unitString.toUpperCase();
|
|
}
|
|
}, {
|
|
key: "isLength",
|
|
value: function isLength() {
|
|
return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS());
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty() {
|
|
return this.numerator.length === 0 && this.denominator.length === 0;
|
|
}
|
|
}, {
|
|
key: "isSingular",
|
|
value: function isSingular() {
|
|
return this.numerator.length <= 1 && this.denominator.length === 0;
|
|
}
|
|
}, {
|
|
key: "map",
|
|
value: function map(callback) {
|
|
var i;
|
|
|
|
for (i = 0; i < this.numerator.length; i++) {
|
|
this.numerator[i] = callback(this.numerator[i], false);
|
|
}
|
|
|
|
for (i = 0; i < this.denominator.length; i++) {
|
|
this.denominator[i] = callback(this.denominator[i], true);
|
|
}
|
|
}
|
|
}, {
|
|
key: "usedUnits",
|
|
value: function usedUnits() {
|
|
var group;
|
|
var result = {};
|
|
var mapUnit;
|
|
var groupName;
|
|
|
|
mapUnit = function mapUnit(atomicUnit) {
|
|
/* jshint loopfunc:true */
|
|
if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
|
|
result[groupName] = atomicUnit;
|
|
}
|
|
|
|
return atomicUnit;
|
|
};
|
|
|
|
for (groupName in unitConversions) {
|
|
if (unitConversions.hasOwnProperty(groupName)) {
|
|
group = unitConversions[groupName];
|
|
this.map(mapUnit);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "cancel",
|
|
value: function cancel() {
|
|
var counter = {};
|
|
var atomicUnit;
|
|
var i;
|
|
|
|
for (i = 0; i < this.numerator.length; i++) {
|
|
atomicUnit = this.numerator[i];
|
|
counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
|
|
}
|
|
|
|
for (i = 0; i < this.denominator.length; i++) {
|
|
atomicUnit = this.denominator[i];
|
|
counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
|
|
}
|
|
|
|
this.numerator = [];
|
|
this.denominator = [];
|
|
|
|
for (atomicUnit in counter) {
|
|
if (counter.hasOwnProperty(atomicUnit)) {
|
|
var count = counter[atomicUnit];
|
|
|
|
if (count > 0) {
|
|
for (i = 0; i < count; i++) {
|
|
this.numerator.push(atomicUnit);
|
|
}
|
|
} else if (count < 0) {
|
|
for (i = 0; i < -count; i++) {
|
|
this.denominator.push(atomicUnit);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.numerator.sort();
|
|
this.denominator.sort();
|
|
}
|
|
}]);
|
|
|
|
return Unit;
|
|
}(Node);
|
|
|
|
Unit.prototype.type = 'Unit';
|
|
|
|
// A number with a unit
|
|
//
|
|
|
|
var Dimension =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Dimension, _Node);
|
|
|
|
function Dimension(value, unit) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Dimension);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Dimension).call(this));
|
|
_this.value = parseFloat(value);
|
|
|
|
if (isNaN(_this.value)) {
|
|
throw new Error('Dimension is not a number.');
|
|
}
|
|
|
|
_this.unit = unit && unit instanceof Unit ? unit : new Unit(unit ? [unit] : undefined);
|
|
|
|
_this.setParent(_this.unit, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Dimension, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.unit = visitor.visit(this.unit);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "toColor",
|
|
value: function toColor() {
|
|
return new Color([this.value, this.value, this.value]);
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
if (context && context.strictUnits && !this.unit.isSingular()) {
|
|
throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`);
|
|
}
|
|
|
|
var value = this.fround(context, this.value);
|
|
var strValue = String(value);
|
|
|
|
if (value !== 0 && value < 0.000001 && value > -0.000001) {
|
|
// would be output 1e-6 etc.
|
|
strValue = value.toFixed(20).replace(/0+$/, '');
|
|
}
|
|
|
|
if (context && context.compress) {
|
|
// Zero values doesn't need a unit
|
|
if (value === 0 && this.unit.isLength()) {
|
|
output.add(strValue);
|
|
return;
|
|
} // Float values doesn't need a leading zero
|
|
|
|
|
|
if (value > 0 && value < 1) {
|
|
strValue = strValue.substr(1);
|
|
}
|
|
}
|
|
|
|
output.add(strValue);
|
|
this.unit.genCSS(context, output);
|
|
} // In an operation between two Dimensions,
|
|
// we default to the first Dimension's unit,
|
|
// so `1px + 2` will yield `3px`.
|
|
|
|
}, {
|
|
key: "operate",
|
|
value: function operate(context, op, other) {
|
|
/* jshint noempty:false */
|
|
var value = this._operate(context, op, this.value, other.value);
|
|
|
|
var unit = this.unit.clone();
|
|
|
|
if (op === '+' || op === '-') {
|
|
if (unit.numerator.length === 0 && unit.denominator.length === 0) {
|
|
unit = other.unit.clone();
|
|
|
|
if (this.unit.backupUnit) {
|
|
unit.backupUnit = this.unit.backupUnit;
|
|
}
|
|
} else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) ; else {
|
|
other = other.convertTo(this.unit.usedUnits());
|
|
|
|
if (context.strictUnits && other.unit.toString() !== unit.toString()) {
|
|
throw new Error(`Incompatible units. Change the units or use the unit function. ` + `Bad units: '${unit.toString()}' and '${other.unit.toString()}'.`);
|
|
}
|
|
|
|
value = this._operate(context, op, this.value, other.value);
|
|
}
|
|
} else if (op === '*') {
|
|
unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
|
|
unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
|
|
unit.cancel();
|
|
} else if (op === '/') {
|
|
unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
|
|
unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
|
|
unit.cancel();
|
|
}
|
|
|
|
return new Dimension(value, unit);
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(other) {
|
|
var a;
|
|
var b;
|
|
|
|
if (!(other instanceof Dimension)) {
|
|
return undefined;
|
|
}
|
|
|
|
if (this.unit.isEmpty() || other.unit.isEmpty()) {
|
|
a = this;
|
|
b = other;
|
|
} else {
|
|
a = this.unify();
|
|
b = other.unify();
|
|
|
|
if (a.unit.compare(b.unit) !== 0) {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
return Node.numericCompare(a.value, b.value);
|
|
}
|
|
}, {
|
|
key: "unify",
|
|
value: function unify() {
|
|
return this.convertTo({
|
|
length: 'px',
|
|
duration: 's',
|
|
angle: 'rad'
|
|
});
|
|
}
|
|
}, {
|
|
key: "convertTo",
|
|
value: function convertTo(conversions) {
|
|
var value = this.value;
|
|
var unit = this.unit.clone();
|
|
var i;
|
|
var groupName;
|
|
var group;
|
|
var targetUnit;
|
|
var derivedConversions = {};
|
|
var applyUnit;
|
|
|
|
if (typeof conversions === 'string') {
|
|
for (i in unitConversions) {
|
|
if (unitConversions[i].hasOwnProperty(conversions)) {
|
|
derivedConversions = {};
|
|
derivedConversions[i] = conversions;
|
|
}
|
|
}
|
|
|
|
conversions = derivedConversions;
|
|
}
|
|
|
|
applyUnit = function applyUnit(atomicUnit, denominator) {
|
|
/* jshint loopfunc:true */
|
|
if (group.hasOwnProperty(atomicUnit)) {
|
|
if (denominator) {
|
|
value = value / (group[atomicUnit] / group[targetUnit]);
|
|
} else {
|
|
value = value * (group[atomicUnit] / group[targetUnit]);
|
|
}
|
|
|
|
return targetUnit;
|
|
}
|
|
|
|
return atomicUnit;
|
|
};
|
|
|
|
for (groupName in conversions) {
|
|
if (conversions.hasOwnProperty(groupName)) {
|
|
targetUnit = conversions[groupName];
|
|
group = unitConversions[groupName];
|
|
unit.map(applyUnit);
|
|
}
|
|
}
|
|
|
|
unit.cancel();
|
|
return new Dimension(value, unit);
|
|
}
|
|
}]);
|
|
|
|
return Dimension;
|
|
}(Node);
|
|
|
|
Dimension.prototype.type = 'Dimension';
|
|
|
|
var MATH$1 = Math$1;
|
|
|
|
var Operation =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Operation, _Node);
|
|
|
|
function Operation(op, operands, isSpaced) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Operation);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Operation).call(this));
|
|
_this.op = op.trim();
|
|
_this.operands = operands;
|
|
_this.isSpaced = isSpaced;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Operation, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.operands = visitor.visitArray(this.operands);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var a = this.operands[0].eval(context);
|
|
var b = this.operands[1].eval(context);
|
|
var op;
|
|
|
|
if (context.isMathOn(this.op)) {
|
|
op = this.op === './' ? '/' : this.op;
|
|
|
|
if (a instanceof Dimension && b instanceof Color) {
|
|
a = a.toColor();
|
|
}
|
|
|
|
if (b instanceof Dimension && a instanceof Color) {
|
|
b = b.toColor();
|
|
}
|
|
|
|
if (!a.operate) {
|
|
if (a instanceof Operation && a.op === '/' && context.math === MATH$1.PARENS_DIVISION) {
|
|
return new Operation(this.op, [a, b], this.isSpaced);
|
|
}
|
|
|
|
throw {
|
|
type: 'Operation',
|
|
message: 'Operation on an invalid type'
|
|
};
|
|
}
|
|
|
|
return a.operate(context, op, b);
|
|
} else {
|
|
return new Operation(this.op, [a, b], this.isSpaced);
|
|
}
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
this.operands[0].genCSS(context, output);
|
|
|
|
if (this.isSpaced) {
|
|
output.add(' ');
|
|
}
|
|
|
|
output.add(this.op);
|
|
|
|
if (this.isSpaced) {
|
|
output.add(' ');
|
|
}
|
|
|
|
this.operands[1].genCSS(context, output);
|
|
}
|
|
}]);
|
|
|
|
return Operation;
|
|
}(Node);
|
|
|
|
Operation.prototype.type = 'Operation';
|
|
|
|
var MATH$2 = Math$1;
|
|
|
|
var Expression =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Expression, _Node);
|
|
|
|
function Expression(value, noSpacing) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Expression);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Expression).call(this));
|
|
_this.value = value;
|
|
_this.noSpacing = noSpacing;
|
|
|
|
if (!value) {
|
|
throw new Error('Expression requires an array parameter');
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Expression, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.value = visitor.visitArray(this.value);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var returnValue;
|
|
var mathOn = context.isMathOn();
|
|
var inParenthesis = this.parens && (context.math !== MATH$2.STRICT_LEGACY || !this.parensInOp);
|
|
var doubleParen = false;
|
|
|
|
if (inParenthesis) {
|
|
context.inParenthesis();
|
|
}
|
|
|
|
if (this.value.length > 1) {
|
|
returnValue = new Expression(this.value.map(function (e) {
|
|
if (!e.eval) {
|
|
return e;
|
|
}
|
|
|
|
return e.eval(context);
|
|
}), this.noSpacing);
|
|
} else if (this.value.length === 1) {
|
|
if (this.value[0].parens && !this.value[0].parensInOp && !context.inCalc) {
|
|
doubleParen = true;
|
|
}
|
|
|
|
returnValue = this.value[0].eval(context);
|
|
} else {
|
|
returnValue = this;
|
|
}
|
|
|
|
if (inParenthesis) {
|
|
context.outOfParenthesis();
|
|
}
|
|
|
|
if (this.parens && this.parensInOp && !mathOn && !doubleParen && !(returnValue instanceof Dimension)) {
|
|
returnValue = new Paren(returnValue);
|
|
}
|
|
|
|
return returnValue;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
for (var i = 0; i < this.value.length; i++) {
|
|
this.value[i].genCSS(context, output);
|
|
|
|
if (!this.noSpacing && i + 1 < this.value.length) {
|
|
output.add(' ');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "throwAwayComments",
|
|
value: function throwAwayComments() {
|
|
this.value = this.value.filter(function (v) {
|
|
return !(v instanceof Comment);
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Expression;
|
|
}(Node);
|
|
|
|
Expression.prototype.type = 'Expression';
|
|
|
|
var functionCaller =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function functionCaller(name, context, index, currentFileInfo) {
|
|
_classCallCheck(this, functionCaller);
|
|
|
|
this.name = name.toLowerCase();
|
|
this.index = index;
|
|
this.context = context;
|
|
this.currentFileInfo = currentFileInfo;
|
|
this.func = context.frames[0].functionRegistry.get(this.name);
|
|
}
|
|
|
|
_createClass(functionCaller, [{
|
|
key: "isValid",
|
|
value: function isValid() {
|
|
return Boolean(this.func);
|
|
}
|
|
}, {
|
|
key: "call",
|
|
value: function call(args) {
|
|
// This code is terrible and should be replaced as per this issue...
|
|
// https://github.com/less/less.js/issues/2477
|
|
if (Array.isArray(args)) {
|
|
args = args.filter(function (item) {
|
|
if (item.type === 'Comment') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}).map(function (item) {
|
|
if (item.type === 'Expression') {
|
|
var subNodes = item.value.filter(function (item) {
|
|
if (item.type === 'Comment') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
if (subNodes.length === 1) {
|
|
return subNodes[0];
|
|
} else {
|
|
return new Expression(subNodes);
|
|
}
|
|
}
|
|
|
|
return item;
|
|
});
|
|
}
|
|
|
|
return this.func.apply(this, _toConsumableArray(args));
|
|
}
|
|
}]);
|
|
|
|
return functionCaller;
|
|
}();
|
|
|
|
// A function call node.
|
|
//
|
|
|
|
var Call =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Call, _Node);
|
|
|
|
function Call(name, args, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Call);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Call).call(this));
|
|
_this.name = name;
|
|
_this.args = args;
|
|
_this.calc = name === 'calc';
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Call, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.args) {
|
|
this.args = visitor.visitArray(this.args);
|
|
}
|
|
} //
|
|
// When evaluating a function call,
|
|
// we either find the function in the functionRegistry,
|
|
// in which case we call it, passing the evaluated arguments,
|
|
// if this returns null or we cannot find the function, we
|
|
// simply print it out as it appeared originally [2].
|
|
//
|
|
// The reason why we evaluate the arguments, is in the case where
|
|
// we try to pass a variable to a function, like: `saturate(@color)`.
|
|
// The function should receive the value, not the variable.
|
|
//
|
|
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
/**
|
|
* Turn off math for calc(), and switch back on for evaluating nested functions
|
|
*/
|
|
var currentMathContext = context.mathOn;
|
|
context.mathOn = !this.calc;
|
|
|
|
if (this.calc || context.inCalc) {
|
|
context.enterCalc();
|
|
}
|
|
|
|
var args = this.args.map(function (a) {
|
|
return a.eval(context);
|
|
});
|
|
|
|
if (this.calc || context.inCalc) {
|
|
context.exitCalc();
|
|
}
|
|
|
|
context.mathOn = currentMathContext;
|
|
var result;
|
|
var funcCaller = new functionCaller(this.name, context, this.getIndex(), this.fileInfo());
|
|
|
|
if (funcCaller.isValid()) {
|
|
try {
|
|
result = funcCaller.call(args);
|
|
} catch (e) {
|
|
throw {
|
|
type: e.type || 'Runtime',
|
|
message: `error evaluating function \`${this.name}\`${e.message ? `: ${e.message}` : ''}`,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
line: e.lineNumber,
|
|
column: e.columnNumber
|
|
};
|
|
}
|
|
|
|
if (result !== null && result !== undefined) {
|
|
// Results that that are not nodes are cast as Anonymous nodes
|
|
// Falsy values or booleans are returned as empty nodes
|
|
if (!(result instanceof Node)) {
|
|
if (!result || result === true) {
|
|
result = new Anonymous(null);
|
|
} else {
|
|
result = new Anonymous(result.toString());
|
|
}
|
|
}
|
|
|
|
result._index = this._index;
|
|
result._fileInfo = this._fileInfo;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
return new Call(this.name, args, this.getIndex(), this.fileInfo());
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(`${this.name}(`, this.fileInfo(), this.getIndex());
|
|
|
|
for (var i = 0; i < this.args.length; i++) {
|
|
this.args[i].genCSS(context, output);
|
|
|
|
if (i + 1 < this.args.length) {
|
|
output.add(', ');
|
|
}
|
|
}
|
|
|
|
output.add(')');
|
|
}
|
|
}]);
|
|
|
|
return Call;
|
|
}(Node);
|
|
|
|
Call.prototype.type = 'Call';
|
|
|
|
var Variable =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Variable, _Node);
|
|
|
|
function Variable(name, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Variable);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Variable).call(this));
|
|
_this.name = name;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Variable, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var variable;
|
|
var name = this.name;
|
|
|
|
if (name.indexOf('@@') === 0) {
|
|
name = `@${new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value}`;
|
|
}
|
|
|
|
if (this.evaluating) {
|
|
throw {
|
|
type: 'Name',
|
|
message: `Recursive variable definition for ${name}`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
|
|
this.evaluating = true;
|
|
variable = this.find(context.frames, function (frame) {
|
|
var v = frame.variable(name);
|
|
|
|
if (v) {
|
|
if (v.important) {
|
|
var importantScope = context.importantScope[context.importantScope.length - 1];
|
|
importantScope.important = v.important;
|
|
} // If in calc, wrap vars in a function call to cascade evaluate args first
|
|
|
|
|
|
if (context.inCalc) {
|
|
return new Call('_SELF', [v.value]).eval(context);
|
|
} else {
|
|
return v.value.eval(context);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (variable) {
|
|
this.evaluating = false;
|
|
return variable;
|
|
} else {
|
|
throw {
|
|
type: 'Name',
|
|
message: `variable ${name} is undefined`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
}
|
|
}, {
|
|
key: "find",
|
|
value: function find(obj, fun) {
|
|
for (var i = 0, r; i < obj.length; i++) {
|
|
r = fun.call(obj, obj[i]);
|
|
|
|
if (r) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Variable;
|
|
}(Node);
|
|
|
|
Variable.prototype.type = 'Variable';
|
|
|
|
var Property =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Property, _Node);
|
|
|
|
function Property(name, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Property);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Property).call(this));
|
|
_this.name = name;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Property, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var property;
|
|
var name = this.name; // TODO: shorten this reference
|
|
|
|
var mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
|
|
|
|
if (this.evaluating) {
|
|
throw {
|
|
type: 'Name',
|
|
message: `Recursive property reference for ${name}`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
|
|
this.evaluating = true;
|
|
property = this.find(context.frames, function (frame) {
|
|
var v;
|
|
var vArr = frame.property(name);
|
|
|
|
if (vArr) {
|
|
for (var i = 0; i < vArr.length; i++) {
|
|
v = vArr[i];
|
|
vArr[i] = new Declaration(v.name, v.value, v.important, v.merge, v.index, v.currentFileInfo, v.inline, v.variable);
|
|
}
|
|
|
|
mergeRules(vArr);
|
|
v = vArr[vArr.length - 1];
|
|
|
|
if (v.important) {
|
|
var importantScope = context.importantScope[context.importantScope.length - 1];
|
|
importantScope.important = v.important;
|
|
}
|
|
|
|
v = v.value.eval(context);
|
|
return v;
|
|
}
|
|
});
|
|
|
|
if (property) {
|
|
this.evaluating = false;
|
|
return property;
|
|
} else {
|
|
throw {
|
|
type: 'Name',
|
|
message: `Property '${name}' is undefined`,
|
|
filename: this.currentFileInfo.filename,
|
|
index: this.index
|
|
};
|
|
}
|
|
}
|
|
}, {
|
|
key: "find",
|
|
value: function find(obj, fun) {
|
|
for (var i = 0, r; i < obj.length; i++) {
|
|
r = fun.call(obj, obj[i]);
|
|
|
|
if (r) {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Property;
|
|
}(Node);
|
|
|
|
Property.prototype.type = 'Property';
|
|
|
|
var Attribute =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Attribute, _Node);
|
|
|
|
function Attribute(key, op, value) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Attribute);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Attribute).call(this));
|
|
_this.key = key;
|
|
_this.op = op;
|
|
_this.value = value;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Attribute, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return new Attribute(this.key.eval ? this.key.eval(context) : this.key, this.op, this.value && this.value.eval ? this.value.eval(context) : this.value);
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(this.toCSS(context));
|
|
}
|
|
}, {
|
|
key: "toCSS",
|
|
value: function toCSS(context) {
|
|
var value = this.key.toCSS ? this.key.toCSS(context) : this.key;
|
|
|
|
if (this.op) {
|
|
value += this.op;
|
|
value += this.value.toCSS ? this.value.toCSS(context) : this.value;
|
|
}
|
|
|
|
return `[${value}]`;
|
|
}
|
|
}]);
|
|
|
|
return Attribute;
|
|
}(Node);
|
|
|
|
Attribute.prototype.type = 'Attribute';
|
|
|
|
var Quoted =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Quoted, _Node);
|
|
|
|
function Quoted(str, content, escaped, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Quoted);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Quoted).call(this));
|
|
_this.escaped = escaped == null ? true : escaped;
|
|
_this.value = content || '';
|
|
_this.quote = str.charAt(0);
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.variableRegex = /@\{([\w-]+)\}/g;
|
|
_this.propRegex = /\$\{([\w-]+)\}/g;
|
|
_this.allowRoot = escaped;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Quoted, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
if (!this.escaped) {
|
|
output.add(this.quote, this.fileInfo(), this.getIndex());
|
|
}
|
|
|
|
output.add(this.value);
|
|
|
|
if (!this.escaped) {
|
|
output.add(this.quote);
|
|
}
|
|
}
|
|
}, {
|
|
key: "containsVariables",
|
|
value: function containsVariables() {
|
|
return this.value.match(this.variableRegex);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var that = this;
|
|
var value = this.value;
|
|
|
|
var variableReplacement = function variableReplacement(_, name) {
|
|
var v = new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context, true);
|
|
return v instanceof Quoted ? v.value : v.toCSS();
|
|
};
|
|
|
|
var propertyReplacement = function propertyReplacement(_, name) {
|
|
var v = new Property(`$${name}`, that.getIndex(), that.fileInfo()).eval(context, true);
|
|
return v instanceof Quoted ? v.value : v.toCSS();
|
|
};
|
|
|
|
function iterativeReplace(value, regexp, replacementFnc) {
|
|
var evaluatedValue = value;
|
|
|
|
do {
|
|
value = evaluatedValue.toString();
|
|
evaluatedValue = value.replace(regexp, replacementFnc);
|
|
} while (value !== evaluatedValue);
|
|
|
|
return evaluatedValue;
|
|
}
|
|
|
|
value = iterativeReplace(value, this.variableRegex, variableReplacement);
|
|
value = iterativeReplace(value, this.propRegex, propertyReplacement);
|
|
return new Quoted(this.quote + value + this.quote, value, this.escaped, this.getIndex(), this.fileInfo());
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(other) {
|
|
// when comparing quoted strings allow the quote to differ
|
|
if (other.type === 'Quoted' && !this.escaped && !other.escaped) {
|
|
return Node.numericCompare(this.value, other.value);
|
|
} else {
|
|
return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Quoted;
|
|
}(Node);
|
|
|
|
Quoted.prototype.type = 'Quoted';
|
|
|
|
var URL =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(URL, _Node);
|
|
|
|
function URL(val, index, currentFileInfo, isEvald) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, URL);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(URL).call(this));
|
|
_this.value = val;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.isEvald = isEvald;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(URL, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.value = visitor.visit(this.value);
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add('url(');
|
|
this.value.genCSS(context, output);
|
|
output.add(')');
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var val = this.value.eval(context);
|
|
var rootpath;
|
|
|
|
if (!this.isEvald) {
|
|
// Add the rootpath if the URL requires a rewrite
|
|
rootpath = this.fileInfo() && this.fileInfo().rootpath;
|
|
|
|
if (typeof rootpath === 'string' && typeof val.value === 'string' && context.pathRequiresRewrite(val.value)) {
|
|
if (!val.quote) {
|
|
rootpath = escapePath(rootpath);
|
|
}
|
|
|
|
val.value = context.rewritePath(val.value, rootpath);
|
|
} else {
|
|
val.value = context.normalizePath(val.value);
|
|
} // Add url args if enabled
|
|
|
|
|
|
if (context.urlArgs) {
|
|
if (!val.value.match(/^\s*data:/)) {
|
|
var delimiter = val.value.indexOf('?') === -1 ? '?' : '&';
|
|
var urlArgs = delimiter + context.urlArgs;
|
|
|
|
if (val.value.indexOf('#') !== -1) {
|
|
val.value = val.value.replace('#', `${urlArgs}#`);
|
|
} else {
|
|
val.value += urlArgs;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new URL(val, this.getIndex(), this.fileInfo(), true);
|
|
}
|
|
}]);
|
|
|
|
return URL;
|
|
}(Node);
|
|
|
|
URL.prototype.type = 'Url';
|
|
|
|
function escapePath(path) {
|
|
return path.replace(/[\(\)'"\s]/g, function (match) {
|
|
return `\\${match}`;
|
|
});
|
|
}
|
|
|
|
var Media =
|
|
/*#__PURE__*/
|
|
function (_AtRule) {
|
|
_inherits(Media, _AtRule);
|
|
|
|
function Media(value, features, index, currentFileInfo, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Media);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Media).call(this));
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
var selectors = new Selector([], null, null, _this._index, _this._fileInfo).createEmptySelectors();
|
|
_this.features = new Value(features);
|
|
_this.rules = [new Ruleset(selectors, value)];
|
|
_this.rules[0].allowImports = true;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.allowRoot = true;
|
|
|
|
_this.setParent(selectors, _assertThisInitialized(_this));
|
|
|
|
_this.setParent(_this.features, _assertThisInitialized(_this));
|
|
|
|
_this.setParent(_this.rules, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Media, [{
|
|
key: "isRulesetLike",
|
|
value: function isRulesetLike() {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.features) {
|
|
this.features = visitor.visit(this.features);
|
|
}
|
|
|
|
if (this.rules) {
|
|
this.rules = visitor.visitArray(this.rules);
|
|
}
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add('@media ', this._fileInfo, this._index);
|
|
this.features.genCSS(context, output);
|
|
this.outputRuleset(context, output, this.rules);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
if (!context.mediaBlocks) {
|
|
context.mediaBlocks = [];
|
|
context.mediaPath = [];
|
|
}
|
|
|
|
var media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
|
|
|
|
if (this.debugInfo) {
|
|
this.rules[0].debugInfo = this.debugInfo;
|
|
media.debugInfo = this.debugInfo;
|
|
}
|
|
|
|
media.features = this.features.eval(context);
|
|
context.mediaPath.push(media);
|
|
context.mediaBlocks.push(media);
|
|
this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
|
|
context.frames.unshift(this.rules[0]);
|
|
media.rules = [this.rules[0].eval(context)];
|
|
context.frames.shift();
|
|
context.mediaPath.pop();
|
|
return context.mediaPath.length === 0 ? media.evalTop(context) : media.evalNested(context);
|
|
}
|
|
}, {
|
|
key: "evalTop",
|
|
value: function evalTop(context) {
|
|
var result = this; // Render all dependent Media blocks.
|
|
|
|
if (context.mediaBlocks.length > 1) {
|
|
var selectors = new Selector([], null, null, this.getIndex(), this.fileInfo()).createEmptySelectors();
|
|
result = new Ruleset(selectors, context.mediaBlocks);
|
|
result.multiMedia = true;
|
|
result.copyVisibilityInfo(this.visibilityInfo());
|
|
this.setParent(result, this);
|
|
}
|
|
|
|
delete context.mediaBlocks;
|
|
delete context.mediaPath;
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "evalNested",
|
|
value: function evalNested(context) {
|
|
var i;
|
|
var value;
|
|
var path = context.mediaPath.concat([this]); // Extract the media-query conditions separated with `,` (OR).
|
|
|
|
for (i = 0; i < path.length; i++) {
|
|
value = path[i].features instanceof Value ? path[i].features.value : path[i].features;
|
|
path[i] = Array.isArray(value) ? value : [value];
|
|
} // Trace all permutations to generate the resulting media-query.
|
|
//
|
|
// (a, b and c) with nested (d, e) ->
|
|
// a and d
|
|
// a and e
|
|
// b and c and d
|
|
// b and c and e
|
|
|
|
|
|
this.features = new Value(this.permute(path).map(function (path) {
|
|
path = path.map(function (fragment) {
|
|
return fragment.toCSS ? fragment : new Anonymous(fragment);
|
|
});
|
|
|
|
for (i = path.length - 1; i > 0; i--) {
|
|
path.splice(i, 0, new Anonymous('and'));
|
|
}
|
|
|
|
return new Expression(path);
|
|
}));
|
|
this.setParent(this.features, this); // Fake a tree-node that doesn't output anything.
|
|
|
|
return new Ruleset([], []);
|
|
}
|
|
}, {
|
|
key: "permute",
|
|
value: function permute(arr) {
|
|
if (arr.length === 0) {
|
|
return [];
|
|
} else if (arr.length === 1) {
|
|
return arr[0];
|
|
} else {
|
|
var result = [];
|
|
var rest = this.permute(arr.slice(1));
|
|
|
|
for (var i = 0; i < rest.length; i++) {
|
|
for (var j = 0; j < arr[0].length; j++) {
|
|
result.push([arr[0][j]].concat(rest[i]));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bubbleSelectors",
|
|
value: function bubbleSelectors(selectors) {
|
|
if (!selectors) {
|
|
return;
|
|
}
|
|
|
|
this.rules = [new Ruleset(copyArray(selectors), [this.rules[0]])];
|
|
this.setParent(this.rules, this);
|
|
}
|
|
}]);
|
|
|
|
return Media;
|
|
}(AtRule);
|
|
|
|
Media.prototype.type = 'Media';
|
|
|
|
// CSS @import node
|
|
//
|
|
// The general strategy here is that we don't want to wait
|
|
// for the parsing to be completed, before we start importing
|
|
// the file. That's because in the context of a browser,
|
|
// most of the time will be spent waiting for the server to respond.
|
|
//
|
|
// On creation, we push the import path to our import queue, though
|
|
// `import,push`, we also pass it a callback, which it'll call once
|
|
// the file has been fetched, and parsed.
|
|
//
|
|
|
|
var Import =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Import, _Node);
|
|
|
|
function Import(path, features, options, index, currentFileInfo, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Import);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Import).call(this));
|
|
_this.options = options;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.path = path;
|
|
_this.features = features;
|
|
_this.allowRoot = true;
|
|
|
|
if (_this.options.less !== undefined || _this.options.inline) {
|
|
_this.css = !_this.options.less || _this.options.inline;
|
|
} else {
|
|
var pathValue = _this.getPath();
|
|
|
|
if (pathValue && /[#\.\&\?]css([\?;].*)?$/.test(pathValue)) {
|
|
_this.css = true;
|
|
}
|
|
}
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.setParent(_this.features, _assertThisInitialized(_this));
|
|
|
|
_this.setParent(_this.path, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Import, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.features) {
|
|
this.features = visitor.visit(this.features);
|
|
}
|
|
|
|
this.path = visitor.visit(this.path);
|
|
|
|
if (!this.options.isPlugin && !this.options.inline && this.root) {
|
|
this.root = visitor.visit(this.root);
|
|
}
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
if (this.css && this.path._fileInfo.reference === undefined) {
|
|
output.add('@import ', this._fileInfo, this._index);
|
|
this.path.genCSS(context, output);
|
|
|
|
if (this.features) {
|
|
output.add(' ');
|
|
this.features.genCSS(context, output);
|
|
}
|
|
|
|
output.add(';');
|
|
}
|
|
}
|
|
}, {
|
|
key: "getPath",
|
|
value: function getPath() {
|
|
return this.path instanceof URL ? this.path.value.value : this.path.value;
|
|
}
|
|
}, {
|
|
key: "isVariableImport",
|
|
value: function isVariableImport() {
|
|
var path = this.path;
|
|
|
|
if (path instanceof URL) {
|
|
path = path.value;
|
|
}
|
|
|
|
if (path instanceof Quoted) {
|
|
return path.containsVariables();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "evalForImport",
|
|
value: function evalForImport(context) {
|
|
var path = this.path;
|
|
|
|
if (path instanceof URL) {
|
|
path = path.value;
|
|
}
|
|
|
|
return new Import(path.eval(context), this.features, this.options, this._index, this._fileInfo, this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "evalPath",
|
|
value: function evalPath(context) {
|
|
var path = this.path.eval(context);
|
|
var fileInfo = this._fileInfo;
|
|
|
|
if (!(path instanceof URL)) {
|
|
// Add the rootpath if the URL requires a rewrite
|
|
var pathValue = path.value;
|
|
|
|
if (fileInfo && pathValue && context.pathRequiresRewrite(pathValue)) {
|
|
path.value = context.rewritePath(pathValue, fileInfo.rootpath);
|
|
} else {
|
|
path.value = context.normalizePath(path.value);
|
|
}
|
|
}
|
|
|
|
return path;
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var result = this.doEval(context);
|
|
|
|
if (this.options.reference || this.blocksVisibility()) {
|
|
if (result.length || result.length === 0) {
|
|
result.forEach(function (node) {
|
|
node.addVisibilityBlock();
|
|
});
|
|
} else {
|
|
result.addVisibilityBlock();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "doEval",
|
|
value: function doEval(context) {
|
|
var ruleset;
|
|
var registry;
|
|
var features = this.features && this.features.eval(context);
|
|
|
|
if (this.options.isPlugin) {
|
|
if (this.root && this.root.eval) {
|
|
try {
|
|
this.root.eval(context);
|
|
} catch (e) {
|
|
e.message = 'Plugin error during evaluation';
|
|
throw new LessError(e, this.root.imports, this.root.filename);
|
|
}
|
|
}
|
|
|
|
registry = context.frames[0] && context.frames[0].functionRegistry;
|
|
|
|
if (registry && this.root && this.root.functions) {
|
|
registry.addMultiple(this.root.functions);
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
if (this.skip) {
|
|
if (typeof this.skip === 'function') {
|
|
this.skip = this.skip();
|
|
}
|
|
|
|
if (this.skip) {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
if (this.options.inline) {
|
|
var contents = new Anonymous(this.root, 0, {
|
|
filename: this.importedFilename,
|
|
reference: this.path._fileInfo && this.path._fileInfo.reference
|
|
}, true, true);
|
|
return this.features ? new Media([contents], this.features.value) : [contents];
|
|
} else if (this.css) {
|
|
var newImport = new Import(this.evalPath(context), features, this.options, this._index);
|
|
|
|
if (!newImport.css && this.error) {
|
|
throw this.error;
|
|
}
|
|
|
|
return newImport;
|
|
} else {
|
|
ruleset = new Ruleset(null, copyArray(this.root.rules));
|
|
ruleset.evalImports(context);
|
|
return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Import;
|
|
}(Node);
|
|
|
|
Import.prototype.type = 'Import';
|
|
|
|
var JsEvalNode =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(JsEvalNode, _Node);
|
|
|
|
function JsEvalNode() {
|
|
_classCallCheck(this, JsEvalNode);
|
|
|
|
return _possibleConstructorReturn(this, _getPrototypeOf(JsEvalNode).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(JsEvalNode, [{
|
|
key: "evaluateJavaScript",
|
|
value: function evaluateJavaScript(expression, context) {
|
|
var result;
|
|
var that = this;
|
|
var evalContext = {};
|
|
|
|
if (!context.javascriptEnabled) {
|
|
throw {
|
|
message: 'Inline JavaScript is not enabled. Is it set in your options?',
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
|
|
expression = expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
|
|
return that.jsify(new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context));
|
|
});
|
|
|
|
try {
|
|
expression = new Function(`return (${expression})`);
|
|
} catch (e) {
|
|
throw {
|
|
message: `JavaScript evaluation error: ${e.message} from \`${expression}\``,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
|
|
var variables = context.frames[0].variables();
|
|
|
|
for (var k in variables) {
|
|
if (variables.hasOwnProperty(k)) {
|
|
/* jshint loopfunc:true */
|
|
evalContext[k.slice(1)] = {
|
|
value: variables[k].value,
|
|
toJS: function toJS() {
|
|
return this.value.eval(context).toCSS();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
try {
|
|
result = expression.call(evalContext);
|
|
} catch (e) {
|
|
throw {
|
|
message: `JavaScript evaluation error: '${e.name}: ${e.message.replace(/["]/g, '\'')}'`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "jsify",
|
|
value: function jsify(obj) {
|
|
if (Array.isArray(obj.value) && obj.value.length > 1) {
|
|
return `[${obj.value.map(function (v) {
|
|
return v.toCSS();
|
|
}).join(', ')}]`;
|
|
} else {
|
|
return obj.toCSS();
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return JsEvalNode;
|
|
}(Node);
|
|
|
|
var JavaScript =
|
|
/*#__PURE__*/
|
|
function (_JsEvalNode) {
|
|
_inherits(JavaScript, _JsEvalNode);
|
|
|
|
function JavaScript(string, escaped, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, JavaScript);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(JavaScript).call(this));
|
|
_this.escaped = escaped;
|
|
_this.expression = string;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(JavaScript, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var result = this.evaluateJavaScript(this.expression, context);
|
|
var type = typeof result;
|
|
|
|
if (type === 'number' && !isNaN(result)) {
|
|
return new Dimension(result);
|
|
} else if (type === 'string') {
|
|
return new Quoted(`"${result}"`, result, this.escaped, this._index);
|
|
} else if (Array.isArray(result)) {
|
|
return new Anonymous(result.join(', '));
|
|
} else {
|
|
return new Anonymous(result);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return JavaScript;
|
|
}(JsEvalNode);
|
|
|
|
JavaScript.prototype.type = 'JavaScript';
|
|
|
|
var Assignment =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Assignment, _Node);
|
|
|
|
function Assignment(key, val) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Assignment);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Assignment).call(this));
|
|
_this.key = key;
|
|
_this.value = val;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Assignment, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.value = visitor.visit(this.value);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
if (this.value.eval) {
|
|
return new Assignment(this.key, this.value.eval(context));
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add(`${this.key}=`);
|
|
|
|
if (this.value.genCSS) {
|
|
this.value.genCSS(context, output);
|
|
} else {
|
|
output.add(this.value);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Assignment;
|
|
}(Node);
|
|
|
|
Assignment.prototype.type = 'Assignment';
|
|
|
|
var Condition =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Condition, _Node);
|
|
|
|
function Condition(op, l, r, i, negate) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Condition);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Condition).call(this));
|
|
_this.op = op.trim();
|
|
_this.lvalue = l;
|
|
_this.rvalue = r;
|
|
_this._index = i;
|
|
_this.negate = negate;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Condition, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.lvalue = visitor.visit(this.lvalue);
|
|
this.rvalue = visitor.visit(this.rvalue);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var result = function (op, a, b) {
|
|
switch (op) {
|
|
case 'and':
|
|
return a && b;
|
|
|
|
case 'or':
|
|
return a || b;
|
|
|
|
default:
|
|
switch (Node.compare(a, b)) {
|
|
case -1:
|
|
return op === '<' || op === '=<' || op === '<=';
|
|
|
|
case 0:
|
|
return op === '=' || op === '>=' || op === '=<' || op === '<=';
|
|
|
|
case 1:
|
|
return op === '>' || op === '>=';
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
}
|
|
}(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
|
|
|
|
return this.negate ? !result : result;
|
|
}
|
|
}]);
|
|
|
|
return Condition;
|
|
}(Node);
|
|
|
|
Condition.prototype.type = 'Condition';
|
|
|
|
var UnicodeDescriptor =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(UnicodeDescriptor, _Node);
|
|
|
|
function UnicodeDescriptor(value) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, UnicodeDescriptor);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(UnicodeDescriptor).call(this));
|
|
_this.value = value;
|
|
return _this;
|
|
}
|
|
|
|
return UnicodeDescriptor;
|
|
}(Node);
|
|
|
|
UnicodeDescriptor.prototype.type = 'UnicodeDescriptor';
|
|
|
|
var Negative =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Negative, _Node);
|
|
|
|
function Negative(node) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Negative);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Negative).call(this));
|
|
_this.value = node;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Negative, [{
|
|
key: "genCSS",
|
|
value: function genCSS(context, output) {
|
|
output.add('-');
|
|
this.value.genCSS(context, output);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
if (context.isMathOn()) {
|
|
return new Operation('*', [new Dimension(-1), this.value]).eval(context);
|
|
}
|
|
|
|
return new Negative(this.value.eval(context));
|
|
}
|
|
}]);
|
|
|
|
return Negative;
|
|
}(Node);
|
|
|
|
Negative.prototype.type = 'Negative';
|
|
|
|
var Extend =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(Extend, _Node);
|
|
|
|
function Extend(selector, option, index, currentFileInfo, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Extend);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Extend).call(this));
|
|
_this.selector = selector;
|
|
_this.option = option;
|
|
_this.object_id = Extend.next_id++;
|
|
_this.parent_ids = [_this.object_id];
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.allowRoot = true;
|
|
|
|
switch (option) {
|
|
case 'all':
|
|
_this.allowBefore = true;
|
|
_this.allowAfter = true;
|
|
break;
|
|
|
|
default:
|
|
_this.allowBefore = false;
|
|
_this.allowAfter = false;
|
|
break;
|
|
}
|
|
|
|
_this.setParent(_this.selector, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Extend, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
this.selector = visitor.visit(this.selector);
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return new Extend(this.selector.eval(context), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
|
|
}
|
|
}, {
|
|
key: "clone",
|
|
value: function clone(context) {
|
|
return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
|
|
} // it concatenates (joins) all selectors in selector array
|
|
|
|
}, {
|
|
key: "findSelfSelectors",
|
|
value: function findSelfSelectors(selectors) {
|
|
var selfElements = [];
|
|
var i;
|
|
var selectorElements;
|
|
|
|
for (i = 0; i < selectors.length; i++) {
|
|
selectorElements = selectors[i].elements; // duplicate the logic in genCSS function inside the selector node.
|
|
// future TODO - move both logics into the selector joiner visitor
|
|
|
|
if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === '') {
|
|
selectorElements[0].combinator.value = ' ';
|
|
}
|
|
|
|
selfElements = selfElements.concat(selectors[i].elements);
|
|
}
|
|
|
|
this.selfSelectors = [new Selector(selfElements)];
|
|
this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
|
|
}
|
|
}]);
|
|
|
|
return Extend;
|
|
}(Node);
|
|
|
|
Extend.next_id = 0;
|
|
Extend.prototype.type = 'Extend';
|
|
|
|
var VariableCall =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(VariableCall, _Node);
|
|
|
|
function VariableCall(variable, index, currentFileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, VariableCall);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(VariableCall).call(this));
|
|
_this.variable = variable;
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.allowRoot = true;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(VariableCall, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var rules;
|
|
var detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);
|
|
var error = new LessError({
|
|
message: `Could not evaluate variable call ${this.variable}`
|
|
});
|
|
|
|
if (!detachedRuleset.ruleset) {
|
|
if (detachedRuleset.rules) {
|
|
rules = detachedRuleset;
|
|
} else if (Array.isArray(detachedRuleset)) {
|
|
rules = new Ruleset('', detachedRuleset);
|
|
} else if (Array.isArray(detachedRuleset.value)) {
|
|
rules = new Ruleset('', detachedRuleset.value);
|
|
} else {
|
|
throw error;
|
|
}
|
|
|
|
detachedRuleset = new DetachedRuleset(rules);
|
|
}
|
|
|
|
if (detachedRuleset.ruleset) {
|
|
return detachedRuleset.callEval(context);
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}]);
|
|
|
|
return VariableCall;
|
|
}(Node);
|
|
|
|
VariableCall.prototype.type = 'VariableCall';
|
|
|
|
var NamespaceValue =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(NamespaceValue, _Node);
|
|
|
|
function NamespaceValue(ruleCall, lookups, important, index, fileInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, NamespaceValue);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(NamespaceValue).call(this));
|
|
_this.value = ruleCall;
|
|
_this.lookups = lookups;
|
|
_this.important = important;
|
|
_this._index = index;
|
|
_this._fileInfo = fileInfo;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(NamespaceValue, [{
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var i;
|
|
var name;
|
|
var rules = this.value.eval(context);
|
|
|
|
for (i = 0; i < this.lookups.length; i++) {
|
|
name = this.lookups[i];
|
|
/**
|
|
* Eval'd DRs return rulesets.
|
|
* Eval'd mixins return rules, so let's make a ruleset if we need it.
|
|
* We need to do this because of late parsing of values
|
|
*/
|
|
|
|
if (Array.isArray(rules)) {
|
|
rules = new Ruleset([new Selector()], rules);
|
|
}
|
|
|
|
if (name === '') {
|
|
rules = rules.lastDeclaration();
|
|
} else if (name.charAt(0) === '@') {
|
|
if (name.charAt(1) === '@') {
|
|
name = `@${new Variable(name.substr(1)).eval(context).value}`;
|
|
}
|
|
|
|
if (rules.variables) {
|
|
rules = rules.variable(name);
|
|
}
|
|
|
|
if (!rules) {
|
|
throw {
|
|
type: 'Name',
|
|
message: `variable ${name} not found`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
}
|
|
} else {
|
|
if (name.substring(0, 2) === '$@') {
|
|
name = `$${new Variable(name.substr(1)).eval(context).value}`;
|
|
} else {
|
|
name = name.charAt(0) === '$' ? name : `$${name}`;
|
|
}
|
|
|
|
if (rules.properties) {
|
|
rules = rules.property(name);
|
|
}
|
|
|
|
if (!rules) {
|
|
throw {
|
|
type: 'Name',
|
|
message: `property "${name.substr(1)}" not found`,
|
|
filename: this.fileInfo().filename,
|
|
index: this.getIndex()
|
|
};
|
|
} // Properties are an array of values, since a ruleset can have multiple props.
|
|
// We pick the last one (the "cascaded" value)
|
|
|
|
|
|
rules = rules[rules.length - 1];
|
|
}
|
|
|
|
if (rules.value) {
|
|
rules = rules.eval(context).value;
|
|
}
|
|
|
|
if (rules.ruleset) {
|
|
rules = rules.ruleset.eval(context);
|
|
}
|
|
}
|
|
|
|
return rules;
|
|
}
|
|
}]);
|
|
|
|
return NamespaceValue;
|
|
}(Node);
|
|
|
|
NamespaceValue.prototype.type = 'NamespaceValue';
|
|
|
|
var Definition =
|
|
/*#__PURE__*/
|
|
function (_Ruleset) {
|
|
_inherits(Definition, _Ruleset);
|
|
|
|
function Definition(name, params, rules, condition, variadic, frames, visibilityInfo) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Definition);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(Definition).call(this));
|
|
_this.name = name || 'anonymous mixin';
|
|
_this.selectors = [new Selector([new Element(null, name, false, _this._index, _this._fileInfo)])];
|
|
_this.params = params;
|
|
_this.condition = condition;
|
|
_this.variadic = variadic;
|
|
_this.arity = params.length;
|
|
_this.rules = rules;
|
|
_this._lookups = {};
|
|
var optionalParameters = [];
|
|
_this.required = params.reduce(function (count, p) {
|
|
if (!p.name || p.name && !p.value) {
|
|
return count + 1;
|
|
} else {
|
|
optionalParameters.push(p.name);
|
|
return count;
|
|
}
|
|
}, 0);
|
|
_this.optionalParameters = optionalParameters;
|
|
_this.frames = frames;
|
|
|
|
_this.copyVisibilityInfo(visibilityInfo);
|
|
|
|
_this.allowRoot = true;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Definition, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.params && this.params.length) {
|
|
this.params = visitor.visitArray(this.params);
|
|
}
|
|
|
|
this.rules = visitor.visitArray(this.rules);
|
|
|
|
if (this.condition) {
|
|
this.condition = visitor.visit(this.condition);
|
|
}
|
|
}
|
|
}, {
|
|
key: "evalParams",
|
|
value: function evalParams(context, mixinEnv, args, evaldArguments) {
|
|
/* jshint boss:true */
|
|
var frame = new Ruleset(null, null);
|
|
var varargs;
|
|
var arg;
|
|
var params = copyArray(this.params);
|
|
var i;
|
|
var j;
|
|
var val;
|
|
var name;
|
|
var isNamedFound;
|
|
var argIndex;
|
|
var argsLength = 0;
|
|
|
|
if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
|
|
frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
|
|
}
|
|
|
|
mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
|
|
|
|
if (args) {
|
|
args = copyArray(args);
|
|
argsLength = args.length;
|
|
|
|
for (i = 0; i < argsLength; i++) {
|
|
arg = args[i];
|
|
|
|
if (name = arg && arg.name) {
|
|
isNamedFound = false;
|
|
|
|
for (j = 0; j < params.length; j++) {
|
|
if (!evaldArguments[j] && name === params[j].name) {
|
|
evaldArguments[j] = arg.value.eval(context);
|
|
frame.prependRule(new Declaration(name, arg.value.eval(context)));
|
|
isNamedFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isNamedFound) {
|
|
args.splice(i, 1);
|
|
i--;
|
|
continue;
|
|
} else {
|
|
throw {
|
|
type: 'Runtime',
|
|
message: `Named argument for ${this.name} ${args[i].name} not found`
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
argIndex = 0;
|
|
|
|
for (i = 0; i < params.length; i++) {
|
|
if (evaldArguments[i]) {
|
|
continue;
|
|
}
|
|
|
|
arg = args && args[argIndex];
|
|
|
|
if (name = params[i].name) {
|
|
if (params[i].variadic) {
|
|
varargs = [];
|
|
|
|
for (j = argIndex; j < argsLength; j++) {
|
|
varargs.push(args[j].value.eval(context));
|
|
}
|
|
|
|
frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
|
|
} else {
|
|
val = arg && arg.value;
|
|
|
|
if (val) {
|
|
// This was a mixin call, pass in a detached ruleset of it's eval'd rules
|
|
if (Array.isArray(val)) {
|
|
val = new DetachedRuleset(new Ruleset('', val));
|
|
} else {
|
|
val = val.eval(context);
|
|
}
|
|
} else if (params[i].value) {
|
|
val = params[i].value.eval(mixinEnv);
|
|
frame.resetCache();
|
|
} else {
|
|
throw {
|
|
type: 'Runtime',
|
|
message: `wrong number of arguments for ${this.name} (${argsLength} for ${this.arity})`
|
|
};
|
|
}
|
|
|
|
frame.prependRule(new Declaration(name, val));
|
|
evaldArguments[i] = val;
|
|
}
|
|
}
|
|
|
|
if (params[i].variadic && args) {
|
|
for (j = argIndex; j < argsLength; j++) {
|
|
evaldArguments[j] = args[j].value.eval(context);
|
|
}
|
|
}
|
|
|
|
argIndex++;
|
|
}
|
|
|
|
return frame;
|
|
}
|
|
}, {
|
|
key: "makeImportant",
|
|
value: function makeImportant() {
|
|
var rules = !this.rules ? this.rules : this.rules.map(function (r) {
|
|
if (r.makeImportant) {
|
|
return r.makeImportant(true);
|
|
} else {
|
|
return r;
|
|
}
|
|
});
|
|
var result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || copyArray(context.frames));
|
|
}
|
|
}, {
|
|
key: "evalCall",
|
|
value: function evalCall(context, args, important) {
|
|
var _arguments = [];
|
|
var mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames;
|
|
var frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments);
|
|
var rules;
|
|
var ruleset;
|
|
frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
|
|
rules = copyArray(this.rules);
|
|
ruleset = new Ruleset(null, rules);
|
|
ruleset.originalRuleset = this;
|
|
ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
|
|
|
|
if (important) {
|
|
ruleset = ruleset.makeImportant();
|
|
}
|
|
|
|
return ruleset;
|
|
}
|
|
}, {
|
|
key: "matchCondition",
|
|
value: function matchCondition(args, context) {
|
|
if (this.condition && !this.condition.eval(new contexts.Eval(context, [this.evalParams(context,
|
|
/* the parameter variables */
|
|
new contexts.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])].concat(this.frames || []) // the parent namespace/mixin frames
|
|
.concat(context.frames)))) {
|
|
// the current environment frames
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "matchArgs",
|
|
value: function matchArgs(args, context) {
|
|
var allArgsCnt = args && args.length || 0;
|
|
var len;
|
|
var optionalParameters = this.optionalParameters;
|
|
var requiredArgsCnt = !args ? 0 : args.reduce(function (count, p) {
|
|
if (optionalParameters.indexOf(p.name) < 0) {
|
|
return count + 1;
|
|
} else {
|
|
return count;
|
|
}
|
|
}, 0);
|
|
|
|
if (!this.variadic) {
|
|
if (requiredArgsCnt < this.required) {
|
|
return false;
|
|
}
|
|
|
|
if (allArgsCnt > this.params.length) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (requiredArgsCnt < this.required - 1) {
|
|
return false;
|
|
}
|
|
} // check patterns
|
|
|
|
|
|
len = Math.min(requiredArgsCnt, this.arity);
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (!this.params[i].name && !this.params[i].variadic) {
|
|
if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}]);
|
|
|
|
return Definition;
|
|
}(Ruleset);
|
|
|
|
Definition.prototype.type = 'MixinDefinition';
|
|
Definition.prototype.evalFirst = true;
|
|
|
|
var MixinCall =
|
|
/*#__PURE__*/
|
|
function (_Node) {
|
|
_inherits(MixinCall, _Node);
|
|
|
|
function MixinCall(elements, args, index, currentFileInfo, important) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MixinCall);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(MixinCall).call(this));
|
|
_this.selector = new Selector(elements);
|
|
_this.arguments = args || [];
|
|
_this._index = index;
|
|
_this._fileInfo = currentFileInfo;
|
|
_this.important = important;
|
|
_this.allowRoot = true;
|
|
|
|
_this.setParent(_this.selector, _assertThisInitialized(_this));
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MixinCall, [{
|
|
key: "accept",
|
|
value: function accept(visitor) {
|
|
if (this.selector) {
|
|
this.selector = visitor.visit(this.selector);
|
|
}
|
|
|
|
if (this.arguments.length) {
|
|
this.arguments = visitor.visitArray(this.arguments);
|
|
}
|
|
}
|
|
}, {
|
|
key: "eval",
|
|
value: function _eval(context) {
|
|
var mixins;
|
|
var mixin;
|
|
var mixinPath;
|
|
var args = [];
|
|
var arg;
|
|
var argValue;
|
|
var rules = [];
|
|
var match = false;
|
|
var i;
|
|
var m;
|
|
var f;
|
|
var isRecursive;
|
|
var isOneFound;
|
|
var candidates = [];
|
|
var candidate;
|
|
var conditionResult = [];
|
|
var defaultResult;
|
|
var defFalseEitherCase = -1;
|
|
var defNone = 0;
|
|
var defTrue = 1;
|
|
var defFalse = 2;
|
|
var count;
|
|
var originalRuleset;
|
|
var noArgumentsFilter;
|
|
this.selector = this.selector.eval(context);
|
|
|
|
function calcDefGroup(mixin, mixinPath) {
|
|
var f;
|
|
var p;
|
|
var namespace;
|
|
|
|
for (f = 0; f < 2; f++) {
|
|
conditionResult[f] = true;
|
|
defaultFunc.value(f);
|
|
|
|
for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
|
|
namespace = mixinPath[p];
|
|
|
|
if (namespace.matchCondition) {
|
|
conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
|
|
}
|
|
}
|
|
|
|
if (mixin.matchCondition) {
|
|
conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
|
|
}
|
|
}
|
|
|
|
if (conditionResult[0] || conditionResult[1]) {
|
|
if (conditionResult[0] != conditionResult[1]) {
|
|
return conditionResult[1] ? defTrue : defFalse;
|
|
}
|
|
|
|
return defNone;
|
|
}
|
|
|
|
return defFalseEitherCase;
|
|
}
|
|
|
|
for (i = 0; i < this.arguments.length; i++) {
|
|
arg = this.arguments[i];
|
|
argValue = arg.value.eval(context);
|
|
|
|
if (arg.expand && Array.isArray(argValue.value)) {
|
|
argValue = argValue.value;
|
|
|
|
for (m = 0; m < argValue.length; m++) {
|
|
args.push({
|
|
value: argValue[m]
|
|
});
|
|
}
|
|
} else {
|
|
args.push({
|
|
name: arg.name,
|
|
value: argValue
|
|
});
|
|
}
|
|
}
|
|
|
|
noArgumentsFilter = function noArgumentsFilter(rule) {
|
|
return rule.matchArgs(null, context);
|
|
};
|
|
|
|
for (i = 0; i < context.frames.length; i++) {
|
|
if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
|
|
isOneFound = true; // To make `default()` function independent of definition order we have two "subpasses" here.
|
|
// At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
|
|
// and build candidate list with corresponding flags. Then, when we know all possible matches,
|
|
// we make a final decision.
|
|
|
|
for (m = 0; m < mixins.length; m++) {
|
|
mixin = mixins[m].rule;
|
|
mixinPath = mixins[m].path;
|
|
isRecursive = false;
|
|
|
|
for (f = 0; f < context.frames.length; f++) {
|
|
if (!(mixin instanceof Definition) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
|
|
isRecursive = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isRecursive) {
|
|
continue;
|
|
}
|
|
|
|
if (mixin.matchArgs(args, context)) {
|
|
candidate = {
|
|
mixin,
|
|
group: calcDefGroup(mixin, mixinPath)
|
|
};
|
|
|
|
if (candidate.group !== defFalseEitherCase) {
|
|
candidates.push(candidate);
|
|
}
|
|
|
|
match = true;
|
|
}
|
|
}
|
|
|
|
defaultFunc.reset();
|
|
count = [0, 0, 0];
|
|
|
|
for (m = 0; m < candidates.length; m++) {
|
|
count[candidates[m].group]++;
|
|
}
|
|
|
|
if (count[defNone] > 0) {
|
|
defaultResult = defFalse;
|
|
} else {
|
|
defaultResult = defTrue;
|
|
|
|
if (count[defTrue] + count[defFalse] > 1) {
|
|
throw {
|
|
type: 'Runtime',
|
|
message: `Ambiguous use of \`default()\` found when matching for \`${this.format(args)}\``,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename
|
|
};
|
|
}
|
|
}
|
|
|
|
for (m = 0; m < candidates.length; m++) {
|
|
candidate = candidates[m].group;
|
|
|
|
if (candidate === defNone || candidate === defaultResult) {
|
|
try {
|
|
mixin = candidates[m].mixin;
|
|
|
|
if (!(mixin instanceof Definition)) {
|
|
originalRuleset = mixin.originalRuleset || mixin;
|
|
mixin = new Definition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
|
|
mixin.originalRuleset = originalRuleset;
|
|
}
|
|
|
|
var newRules = mixin.evalCall(context, args, this.important).rules;
|
|
|
|
this._setVisibilityToReplacement(newRules);
|
|
|
|
Array.prototype.push.apply(rules, newRules);
|
|
} catch (e) {
|
|
throw {
|
|
message: e.message,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename,
|
|
stack: e.stack
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (match) {
|
|
return rules;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isOneFound) {
|
|
throw {
|
|
type: 'Runtime',
|
|
message: `No matching definition was found for \`${this.format(args)}\``,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename
|
|
};
|
|
} else {
|
|
throw {
|
|
type: 'Name',
|
|
message: `${this.selector.toCSS().trim()} is undefined`,
|
|
index: this.getIndex(),
|
|
filename: this.fileInfo().filename
|
|
};
|
|
}
|
|
}
|
|
}, {
|
|
key: "_setVisibilityToReplacement",
|
|
value: function _setVisibilityToReplacement(replacement) {
|
|
var i;
|
|
var rule;
|
|
|
|
if (this.blocksVisibility()) {
|
|
for (i = 0; i < replacement.length; i++) {
|
|
rule = replacement[i];
|
|
rule.addVisibilityBlock();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "format",
|
|
value: function format(args) {
|
|
return `${this.selector.toCSS().trim()}(${args ? args.map(function (a) {
|
|
var argValue = '';
|
|
|
|
if (a.name) {
|
|
argValue += `${a.name}:`;
|
|
}
|
|
|
|
if (a.value.toCSS) {
|
|
argValue += a.value.toCSS();
|
|
} else {
|
|
argValue += '???';
|
|
}
|
|
|
|
return argValue;
|
|
}).join(', ') : ''})`;
|
|
}
|
|
}]);
|
|
|
|
return MixinCall;
|
|
}(Node);
|
|
|
|
MixinCall.prototype.type = 'MixinCall';
|
|
|
|
var tree = {
|
|
Node,
|
|
Color,
|
|
AtRule,
|
|
DetachedRuleset,
|
|
Operation,
|
|
Dimension,
|
|
Unit,
|
|
Keyword,
|
|
Variable,
|
|
Property,
|
|
Ruleset,
|
|
Element,
|
|
Attribute,
|
|
Combinator,
|
|
Selector,
|
|
Quoted,
|
|
Expression,
|
|
Declaration,
|
|
Call,
|
|
URL,
|
|
Import,
|
|
Comment,
|
|
Anonymous,
|
|
Value,
|
|
JavaScript,
|
|
Assignment,
|
|
Condition,
|
|
Paren,
|
|
Media,
|
|
UnicodeDescriptor,
|
|
Negative,
|
|
Extend,
|
|
VariableCall,
|
|
NamespaceValue,
|
|
mixin: {
|
|
Call: MixinCall,
|
|
Definition: Definition
|
|
}
|
|
};
|
|
|
|
var environment$1 =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function environment(externalEnvironment, fileManagers) {
|
|
_classCallCheck(this, environment);
|
|
|
|
this.fileManagers = fileManagers || [];
|
|
externalEnvironment = externalEnvironment || {};
|
|
var optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'];
|
|
var requiredFunctions = [];
|
|
var functions = requiredFunctions.concat(optionalFunctions);
|
|
|
|
for (var i = 0; i < functions.length; i++) {
|
|
var propName = functions[i];
|
|
var environmentFunc = externalEnvironment[propName];
|
|
|
|
if (environmentFunc) {
|
|
this[propName] = environmentFunc.bind(externalEnvironment);
|
|
} else if (i < requiredFunctions.length) {
|
|
this.warn(`missing required function in environment - ${propName}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
_createClass(environment, [{
|
|
key: "getFileManager",
|
|
value: function getFileManager(filename, currentDirectory, options, environment, isSync) {
|
|
if (!filename) {
|
|
logger.warn('getFileManager called with no filename.. Please report this issue. continuing.');
|
|
}
|
|
|
|
if (currentDirectory == null) {
|
|
logger.warn('getFileManager called with null directory.. Please report this issue. continuing.');
|
|
}
|
|
|
|
var fileManagers = this.fileManagers;
|
|
|
|
if (options.pluginManager) {
|
|
fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
|
|
}
|
|
|
|
for (var i = fileManagers.length - 1; i >= 0; i--) {
|
|
var fileManager = fileManagers[i];
|
|
|
|
if (fileManager[isSync ? 'supportsSync' : 'supports'](filename, currentDirectory, options, environment)) {
|
|
return fileManager;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "addFileManager",
|
|
value: function addFileManager(fileManager) {
|
|
this.fileManagers.push(fileManager);
|
|
}
|
|
}, {
|
|
key: "clearFileManagers",
|
|
value: function clearFileManagers() {
|
|
this.fileManagers = [];
|
|
}
|
|
}]);
|
|
|
|
return environment;
|
|
}();
|
|
|
|
var AbstractPluginLoader =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function AbstractPluginLoader() {
|
|
_classCallCheck(this, AbstractPluginLoader);
|
|
|
|
// Implemented by Node.js plugin loader
|
|
this.require = function () {
|
|
return null;
|
|
};
|
|
}
|
|
|
|
_createClass(AbstractPluginLoader, [{
|
|
key: "evalPlugin",
|
|
value: function evalPlugin(contents, context, imports, pluginOptions, fileInfo) {
|
|
var loader;
|
|
var registry;
|
|
var pluginObj;
|
|
var localModule;
|
|
var pluginManager;
|
|
var filename;
|
|
var result;
|
|
pluginManager = context.pluginManager;
|
|
|
|
if (fileInfo) {
|
|
if (typeof fileInfo === 'string') {
|
|
filename = fileInfo;
|
|
} else {
|
|
filename = fileInfo.filename;
|
|
}
|
|
}
|
|
|
|
var shortname = new this.less.FileManager().extractUrlParts(filename).filename;
|
|
|
|
if (filename) {
|
|
pluginObj = pluginManager.get(filename);
|
|
|
|
if (pluginObj) {
|
|
result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
|
|
|
|
if (result) {
|
|
return result;
|
|
}
|
|
|
|
try {
|
|
if (pluginObj.use) {
|
|
pluginObj.use.call(this.context, pluginObj);
|
|
}
|
|
} catch (e) {
|
|
e.message = e.message || 'Error during @plugin call';
|
|
return new LessError(e, imports, filename);
|
|
}
|
|
|
|
return pluginObj;
|
|
}
|
|
}
|
|
|
|
localModule = {
|
|
exports: {},
|
|
pluginManager,
|
|
fileInfo
|
|
};
|
|
registry = functionRegistry.create();
|
|
|
|
var registerPlugin = function registerPlugin(obj) {
|
|
pluginObj = obj;
|
|
};
|
|
|
|
try {
|
|
loader = new Function('module', 'require', 'registerPlugin', 'functions', 'tree', 'less', 'fileInfo', contents);
|
|
loader(localModule, this.require(filename), registerPlugin, registry, this.less.tree, this.less, fileInfo);
|
|
} catch (e) {
|
|
return new LessError(e, imports, filename);
|
|
}
|
|
|
|
if (!pluginObj) {
|
|
pluginObj = localModule.exports;
|
|
}
|
|
|
|
pluginObj = this.validatePlugin(pluginObj, filename, shortname);
|
|
|
|
if (pluginObj instanceof LessError) {
|
|
return pluginObj;
|
|
}
|
|
|
|
if (pluginObj) {
|
|
pluginObj.imports = imports;
|
|
pluginObj.filename = filename; // For < 3.x (or unspecified minVersion) - setOptions() before install()
|
|
|
|
if (!pluginObj.minVersion || this.compareVersion('3.0.0', pluginObj.minVersion) < 0) {
|
|
result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
|
|
|
|
if (result) {
|
|
return result;
|
|
}
|
|
} // Run on first load
|
|
|
|
|
|
pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
|
|
pluginObj.functions = registry.getLocalFunctions(); // Need to call setOptions again because the pluginObj might have functions
|
|
|
|
result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
|
|
|
|
if (result) {
|
|
return result;
|
|
} // Run every @plugin call
|
|
|
|
|
|
try {
|
|
if (pluginObj.use) {
|
|
pluginObj.use.call(this.context, pluginObj);
|
|
}
|
|
} catch (e) {
|
|
e.message = e.message || 'Error during @plugin call';
|
|
return new LessError(e, imports, filename);
|
|
}
|
|
} else {
|
|
return new LessError({
|
|
message: 'Not a valid plugin'
|
|
}, imports, filename);
|
|
}
|
|
|
|
return pluginObj;
|
|
}
|
|
}, {
|
|
key: "trySetOptions",
|
|
value: function trySetOptions(plugin, filename, name, options) {
|
|
if (options && !plugin.setOptions) {
|
|
return new LessError({
|
|
message: `Options have been provided but the plugin ${name} does not support any options.`
|
|
});
|
|
}
|
|
|
|
try {
|
|
plugin.setOptions && plugin.setOptions(options);
|
|
} catch (e) {
|
|
return new LessError(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "validatePlugin",
|
|
value: function validatePlugin(plugin, filename, name) {
|
|
if (plugin) {
|
|
// support plugins being a function
|
|
// so that the plugin can be more usable programmatically
|
|
if (typeof plugin === 'function') {
|
|
plugin = new plugin();
|
|
}
|
|
|
|
if (plugin.minVersion) {
|
|
if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
|
|
return new LessError({
|
|
message: `Plugin ${name} requires version ${this.versionToString(plugin.minVersion)}`
|
|
});
|
|
}
|
|
}
|
|
|
|
return plugin;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "compareVersion",
|
|
value: function compareVersion(aVersion, bVersion) {
|
|
if (typeof aVersion === 'string') {
|
|
aVersion = aVersion.match(/^(\d+)\.?(\d+)?\.?(\d+)?/);
|
|
aVersion.shift();
|
|
}
|
|
|
|
for (var i = 0; i < aVersion.length; i++) {
|
|
if (aVersion[i] !== bVersion[i]) {
|
|
return parseInt(aVersion[i]) > parseInt(bVersion[i]) ? -1 : 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}, {
|
|
key: "versionToString",
|
|
value: function versionToString(version) {
|
|
var versionString = '';
|
|
|
|
for (var i = 0; i < version.length; i++) {
|
|
versionString += (versionString ? '.' : '') + version[i];
|
|
}
|
|
|
|
return versionString;
|
|
}
|
|
}, {
|
|
key: "printUsage",
|
|
value: function printUsage(plugins) {
|
|
for (var i = 0; i < plugins.length; i++) {
|
|
var plugin = plugins[i];
|
|
|
|
if (plugin.printUsage) {
|
|
plugin.printUsage();
|
|
}
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AbstractPluginLoader;
|
|
}();
|
|
|
|
var _visitArgs = {
|
|
visitDeeper: true
|
|
};
|
|
var _hasIndexed = false;
|
|
|
|
function _noop(node) {
|
|
return node;
|
|
}
|
|
|
|
function indexNodeTypes(parent, ticker) {
|
|
// add .typeIndex to tree node types for lookup table
|
|
var key;
|
|
var child;
|
|
|
|
for (key in parent) {
|
|
/* eslint guard-for-in: 0 */
|
|
child = parent[key];
|
|
|
|
switch (typeof child) {
|
|
case 'function':
|
|
// ignore bound functions directly on tree which do not have a prototype
|
|
// or aren't nodes
|
|
if (child.prototype && child.prototype.type) {
|
|
child.prototype.typeIndex = ticker++;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'object':
|
|
ticker = indexNodeTypes(child, ticker);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ticker;
|
|
}
|
|
|
|
var Visitor =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Visitor(implementation) {
|
|
_classCallCheck(this, Visitor);
|
|
|
|
this._implementation = implementation;
|
|
this._visitInCache = {};
|
|
this._visitOutCache = {};
|
|
|
|
if (!_hasIndexed) {
|
|
indexNodeTypes(tree, 1);
|
|
_hasIndexed = true;
|
|
}
|
|
}
|
|
|
|
_createClass(Visitor, [{
|
|
key: "visit",
|
|
value: function visit(node) {
|
|
if (!node) {
|
|
return node;
|
|
}
|
|
|
|
var nodeTypeIndex = node.typeIndex;
|
|
|
|
if (!nodeTypeIndex) {
|
|
// MixinCall args aren't a node type?
|
|
if (node.value && node.value.typeIndex) {
|
|
this.visit(node.value);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
var impl = this._implementation;
|
|
var func = this._visitInCache[nodeTypeIndex];
|
|
var funcOut = this._visitOutCache[nodeTypeIndex];
|
|
var visitArgs = _visitArgs;
|
|
var fnName;
|
|
visitArgs.visitDeeper = true;
|
|
|
|
if (!func) {
|
|
fnName = `visit${node.type}`;
|
|
func = impl[fnName] || _noop;
|
|
funcOut = impl[`${fnName}Out`] || _noop;
|
|
this._visitInCache[nodeTypeIndex] = func;
|
|
this._visitOutCache[nodeTypeIndex] = funcOut;
|
|
}
|
|
|
|
if (func !== _noop) {
|
|
var newNode = func.call(impl, node, visitArgs);
|
|
|
|
if (node && impl.isReplacing) {
|
|
node = newNode;
|
|
}
|
|
}
|
|
|
|
if (visitArgs.visitDeeper && node && node.accept) {
|
|
node.accept(this);
|
|
}
|
|
|
|
if (funcOut != _noop) {
|
|
funcOut.call(impl, node);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
}, {
|
|
key: "visitArray",
|
|
value: function visitArray(nodes, nonReplacing) {
|
|
if (!nodes) {
|
|
return nodes;
|
|
}
|
|
|
|
var cnt = nodes.length;
|
|
var i; // Non-replacing
|
|
|
|
if (nonReplacing || !this._implementation.isReplacing) {
|
|
for (i = 0; i < cnt; i++) {
|
|
this.visit(nodes[i]);
|
|
}
|
|
|
|
return nodes;
|
|
} // Replacing
|
|
|
|
|
|
var out = [];
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
var evald = this.visit(nodes[i]);
|
|
|
|
if (evald === undefined) {
|
|
continue;
|
|
}
|
|
|
|
if (!evald.splice) {
|
|
out.push(evald);
|
|
} else if (evald.length) {
|
|
this.flatten(evald, out);
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
}, {
|
|
key: "flatten",
|
|
value: function flatten(arr, out) {
|
|
if (!out) {
|
|
out = [];
|
|
}
|
|
|
|
var cnt;
|
|
var i;
|
|
var item;
|
|
var nestedCnt;
|
|
var j;
|
|
var nestedItem;
|
|
|
|
for (i = 0, cnt = arr.length; i < cnt; i++) {
|
|
item = arr[i];
|
|
|
|
if (item === undefined) {
|
|
continue;
|
|
}
|
|
|
|
if (!item.splice) {
|
|
out.push(item);
|
|
continue;
|
|
}
|
|
|
|
for (j = 0, nestedCnt = item.length; j < nestedCnt; j++) {
|
|
nestedItem = item[j];
|
|
|
|
if (nestedItem === undefined) {
|
|
continue;
|
|
}
|
|
|
|
if (!nestedItem.splice) {
|
|
out.push(nestedItem);
|
|
} else if (nestedItem.length) {
|
|
this.flatten(nestedItem, out);
|
|
}
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
}]);
|
|
|
|
return Visitor;
|
|
}();
|
|
|
|
var ImportSequencer =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ImportSequencer(onSequencerEmpty) {
|
|
_classCallCheck(this, ImportSequencer);
|
|
|
|
this.imports = [];
|
|
this.variableImports = [];
|
|
this._onSequencerEmpty = onSequencerEmpty;
|
|
this._currentDepth = 0;
|
|
}
|
|
|
|
_createClass(ImportSequencer, [{
|
|
key: "addImport",
|
|
value: function addImport(callback) {
|
|
var importSequencer = this;
|
|
var importItem = {
|
|
callback,
|
|
args: null,
|
|
isReady: false
|
|
};
|
|
this.imports.push(importItem);
|
|
return function () {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
importItem.args = Array.prototype.slice.call(args, 0);
|
|
importItem.isReady = true;
|
|
importSequencer.tryRun();
|
|
};
|
|
}
|
|
}, {
|
|
key: "addVariableImport",
|
|
value: function addVariableImport(callback) {
|
|
this.variableImports.push(callback);
|
|
}
|
|
}, {
|
|
key: "tryRun",
|
|
value: function tryRun() {
|
|
this._currentDepth++;
|
|
|
|
try {
|
|
while (true) {
|
|
while (this.imports.length > 0) {
|
|
var importItem = this.imports[0];
|
|
|
|
if (!importItem.isReady) {
|
|
return;
|
|
}
|
|
|
|
this.imports = this.imports.slice(1);
|
|
importItem.callback.apply(null, importItem.args);
|
|
}
|
|
|
|
if (this.variableImports.length === 0) {
|
|
break;
|
|
}
|
|
|
|
var variableImport = this.variableImports[0];
|
|
this.variableImports = this.variableImports.slice(1);
|
|
variableImport();
|
|
}
|
|
} finally {
|
|
this._currentDepth--;
|
|
}
|
|
|
|
if (this._currentDepth === 0 && this._onSequencerEmpty) {
|
|
this._onSequencerEmpty();
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return ImportSequencer;
|
|
}();
|
|
|
|
var ImportVisitor = function ImportVisitor(importer, finish) {
|
|
this._visitor = new Visitor(this);
|
|
this._importer = importer;
|
|
this._finish = finish;
|
|
this.context = new contexts.Eval();
|
|
this.importCount = 0;
|
|
this.onceFileDetectionMap = {};
|
|
this.recursionDetector = {};
|
|
this._sequencer = new ImportSequencer(this._onSequencerEmpty.bind(this));
|
|
};
|
|
|
|
ImportVisitor.prototype = {
|
|
isReplacing: false,
|
|
run: function run(root) {
|
|
try {
|
|
// process the contents
|
|
this._visitor.visit(root);
|
|
} catch (e) {
|
|
this.error = e;
|
|
}
|
|
|
|
this.isFinished = true;
|
|
|
|
this._sequencer.tryRun();
|
|
},
|
|
_onSequencerEmpty: function _onSequencerEmpty() {
|
|
if (!this.isFinished) {
|
|
return;
|
|
}
|
|
|
|
this._finish(this.error);
|
|
},
|
|
visitImport: function visitImport(importNode, visitArgs) {
|
|
var inlineCSS = importNode.options.inline;
|
|
|
|
if (!importNode.css || inlineCSS) {
|
|
var context = new contexts.Eval(this.context, copyArray(this.context.frames));
|
|
var importParent = context.frames[0];
|
|
this.importCount++;
|
|
|
|
if (importNode.isVariableImport()) {
|
|
this._sequencer.addVariableImport(this.processImportNode.bind(this, importNode, context, importParent));
|
|
} else {
|
|
this.processImportNode(importNode, context, importParent);
|
|
}
|
|
}
|
|
|
|
visitArgs.visitDeeper = false;
|
|
},
|
|
processImportNode: function processImportNode(importNode, context, importParent) {
|
|
var evaldImportNode;
|
|
var inlineCSS = importNode.options.inline;
|
|
|
|
try {
|
|
evaldImportNode = importNode.evalForImport(context);
|
|
} catch (e) {
|
|
if (!e.filename) {
|
|
e.index = importNode.getIndex();
|
|
e.filename = importNode.fileInfo().filename;
|
|
} // attempt to eval properly and treat as css
|
|
|
|
|
|
importNode.css = true; // if that fails, this error will be thrown
|
|
|
|
importNode.error = e;
|
|
}
|
|
|
|
if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
|
|
if (evaldImportNode.options.multiple) {
|
|
context.importMultiple = true;
|
|
} // try appending if we haven't determined if it is css or not
|
|
|
|
|
|
var tryAppendLessExtension = evaldImportNode.css === undefined;
|
|
|
|
for (var i = 0; i < importParent.rules.length; i++) {
|
|
if (importParent.rules[i] === importNode) {
|
|
importParent.rules[i] = evaldImportNode;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var onImported = this.onImported.bind(this, evaldImportNode, context);
|
|
|
|
var sequencedOnImported = this._sequencer.addImport(onImported);
|
|
|
|
this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(), evaldImportNode.options, sequencedOnImported);
|
|
} else {
|
|
this.importCount--;
|
|
|
|
if (this.isFinished) {
|
|
this._sequencer.tryRun();
|
|
}
|
|
}
|
|
},
|
|
onImported: function onImported(importNode, context, e, root, importedAtRoot, fullPath) {
|
|
if (e) {
|
|
if (!e.filename) {
|
|
e.index = importNode.getIndex();
|
|
e.filename = importNode.fileInfo().filename;
|
|
}
|
|
|
|
this.error = e;
|
|
}
|
|
|
|
var importVisitor = this;
|
|
var inlineCSS = importNode.options.inline;
|
|
var isPlugin = importNode.options.isPlugin;
|
|
var isOptional = importNode.options.optional;
|
|
var duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
|
|
|
|
if (!context.importMultiple) {
|
|
if (duplicateImport) {
|
|
importNode.skip = true;
|
|
} else {
|
|
importNode.skip = function () {
|
|
if (fullPath in importVisitor.onceFileDetectionMap) {
|
|
return true;
|
|
}
|
|
|
|
importVisitor.onceFileDetectionMap[fullPath] = true;
|
|
return false;
|
|
};
|
|
}
|
|
}
|
|
|
|
if (!fullPath && isOptional) {
|
|
importNode.skip = true;
|
|
}
|
|
|
|
if (root) {
|
|
importNode.root = root;
|
|
importNode.importedFilename = fullPath;
|
|
|
|
if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
|
|
importVisitor.recursionDetector[fullPath] = true;
|
|
var oldContext = this.context;
|
|
this.context = context;
|
|
|
|
try {
|
|
this._visitor.visit(root);
|
|
} catch (e) {
|
|
this.error = e;
|
|
}
|
|
|
|
this.context = oldContext;
|
|
}
|
|
}
|
|
|
|
importVisitor.importCount--;
|
|
|
|
if (importVisitor.isFinished) {
|
|
importVisitor._sequencer.tryRun();
|
|
}
|
|
},
|
|
visitDeclaration: function visitDeclaration(declNode, visitArgs) {
|
|
if (declNode.value.type === 'DetachedRuleset') {
|
|
this.context.frames.unshift(declNode);
|
|
} else {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
},
|
|
visitDeclarationOut: function visitDeclarationOut(declNode) {
|
|
if (declNode.value.type === 'DetachedRuleset') {
|
|
this.context.frames.shift();
|
|
}
|
|
},
|
|
visitAtRule: function visitAtRule(atRuleNode, visitArgs) {
|
|
this.context.frames.unshift(atRuleNode);
|
|
},
|
|
visitAtRuleOut: function visitAtRuleOut(atRuleNode) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitMixinDefinition: function visitMixinDefinition(mixinDefinitionNode, visitArgs) {
|
|
this.context.frames.unshift(mixinDefinitionNode);
|
|
},
|
|
visitMixinDefinitionOut: function visitMixinDefinitionOut(mixinDefinitionNode) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitRuleset: function visitRuleset(rulesetNode, visitArgs) {
|
|
this.context.frames.unshift(rulesetNode);
|
|
},
|
|
visitRulesetOut: function visitRulesetOut(rulesetNode) {
|
|
this.context.frames.shift();
|
|
},
|
|
visitMedia: function visitMedia(mediaNode, visitArgs) {
|
|
this.context.frames.unshift(mediaNode.rules[0]);
|
|
},
|
|
visitMediaOut: function visitMediaOut(mediaNode) {
|
|
this.context.frames.shift();
|
|
}
|
|
};
|
|
|
|
var SetTreeVisibilityVisitor =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function SetTreeVisibilityVisitor(visible) {
|
|
_classCallCheck(this, SetTreeVisibilityVisitor);
|
|
|
|
this.visible = visible;
|
|
}
|
|
|
|
_createClass(SetTreeVisibilityVisitor, [{
|
|
key: "run",
|
|
value: function run(root) {
|
|
this.visit(root);
|
|
}
|
|
}, {
|
|
key: "visitArray",
|
|
value: function visitArray(nodes) {
|
|
if (!nodes) {
|
|
return nodes;
|
|
}
|
|
|
|
var cnt = nodes.length;
|
|
var i;
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
this.visit(nodes[i]);
|
|
}
|
|
|
|
return nodes;
|
|
}
|
|
}, {
|
|
key: "visit",
|
|
value: function visit(node) {
|
|
if (!node) {
|
|
return node;
|
|
}
|
|
|
|
if (node.constructor === Array) {
|
|
return this.visitArray(node);
|
|
}
|
|
|
|
if (!node.blocksVisibility || node.blocksVisibility()) {
|
|
return node;
|
|
}
|
|
|
|
if (this.visible) {
|
|
node.ensureVisibility();
|
|
} else {
|
|
node.ensureInvisibility();
|
|
}
|
|
|
|
node.accept(this);
|
|
return node;
|
|
}
|
|
}]);
|
|
|
|
return SetTreeVisibilityVisitor;
|
|
}();
|
|
|
|
/* jshint loopfunc:true */
|
|
|
|
var ExtendFinderVisitor =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ExtendFinderVisitor() {
|
|
_classCallCheck(this, ExtendFinderVisitor);
|
|
|
|
this._visitor = new Visitor(this);
|
|
this.contexts = [];
|
|
this.allExtendsStack = [[]];
|
|
}
|
|
|
|
_createClass(ExtendFinderVisitor, [{
|
|
key: "run",
|
|
value: function run(root) {
|
|
root = this._visitor.visit(root);
|
|
root.allExtends = this.allExtendsStack[0];
|
|
return root;
|
|
}
|
|
}, {
|
|
key: "visitDeclaration",
|
|
value: function visitDeclaration(declNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitMixinDefinition",
|
|
value: function visitMixinDefinition(mixinDefinitionNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitRuleset",
|
|
value: function visitRuleset(rulesetNode, visitArgs) {
|
|
if (rulesetNode.root) {
|
|
return;
|
|
}
|
|
|
|
var i;
|
|
var j;
|
|
var extend;
|
|
var allSelectorsExtendList = [];
|
|
var extendList; // get &:extend(.a); rules which apply to all selectors in this ruleset
|
|
|
|
var rules = rulesetNode.rules;
|
|
var ruleCnt = rules ? rules.length : 0;
|
|
|
|
for (i = 0; i < ruleCnt; i++) {
|
|
if (rulesetNode.rules[i] instanceof tree.Extend) {
|
|
allSelectorsExtendList.push(rules[i]);
|
|
rulesetNode.extendOnEveryPath = true;
|
|
}
|
|
} // now find every selector and apply the extends that apply to all extends
|
|
// and the ones which apply to an individual extend
|
|
|
|
|
|
var paths = rulesetNode.paths;
|
|
|
|
for (i = 0; i < paths.length; i++) {
|
|
var selectorPath = paths[i];
|
|
var selector = selectorPath[selectorPath.length - 1];
|
|
var selExtendList = selector.extendList;
|
|
extendList = selExtendList ? copyArray(selExtendList).concat(allSelectorsExtendList) : allSelectorsExtendList;
|
|
|
|
if (extendList) {
|
|
extendList = extendList.map(function (allSelectorsExtend) {
|
|
return allSelectorsExtend.clone();
|
|
});
|
|
}
|
|
|
|
for (j = 0; j < extendList.length; j++) {
|
|
this.foundExtends = true;
|
|
extend = extendList[j];
|
|
extend.findSelfSelectors(selectorPath);
|
|
extend.ruleset = rulesetNode;
|
|
|
|
if (j === 0) {
|
|
extend.firstExtendOnThisSelectorPath = true;
|
|
}
|
|
|
|
this.allExtendsStack[this.allExtendsStack.length - 1].push(extend);
|
|
}
|
|
}
|
|
|
|
this.contexts.push(rulesetNode.selectors);
|
|
}
|
|
}, {
|
|
key: "visitRulesetOut",
|
|
value: function visitRulesetOut(rulesetNode) {
|
|
if (!rulesetNode.root) {
|
|
this.contexts.length = this.contexts.length - 1;
|
|
}
|
|
}
|
|
}, {
|
|
key: "visitMedia",
|
|
value: function visitMedia(mediaNode, visitArgs) {
|
|
mediaNode.allExtends = [];
|
|
this.allExtendsStack.push(mediaNode.allExtends);
|
|
}
|
|
}, {
|
|
key: "visitMediaOut",
|
|
value: function visitMediaOut(mediaNode) {
|
|
this.allExtendsStack.length = this.allExtendsStack.length - 1;
|
|
}
|
|
}, {
|
|
key: "visitAtRule",
|
|
value: function visitAtRule(atRuleNode, visitArgs) {
|
|
atRuleNode.allExtends = [];
|
|
this.allExtendsStack.push(atRuleNode.allExtends);
|
|
}
|
|
}, {
|
|
key: "visitAtRuleOut",
|
|
value: function visitAtRuleOut(atRuleNode) {
|
|
this.allExtendsStack.length = this.allExtendsStack.length - 1;
|
|
}
|
|
}]);
|
|
|
|
return ExtendFinderVisitor;
|
|
}();
|
|
|
|
var ProcessExtendsVisitor =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ProcessExtendsVisitor() {
|
|
_classCallCheck(this, ProcessExtendsVisitor);
|
|
|
|
this._visitor = new Visitor(this);
|
|
}
|
|
|
|
_createClass(ProcessExtendsVisitor, [{
|
|
key: "run",
|
|
value: function run(root) {
|
|
var extendFinder = new ExtendFinderVisitor();
|
|
this.extendIndices = {};
|
|
extendFinder.run(root);
|
|
|
|
if (!extendFinder.foundExtends) {
|
|
return root;
|
|
}
|
|
|
|
root.allExtends = root.allExtends.concat(this.doExtendChaining(root.allExtends, root.allExtends));
|
|
this.allExtendsStack = [root.allExtends];
|
|
|
|
var newRoot = this._visitor.visit(root);
|
|
|
|
this.checkExtendsForNonMatched(root.allExtends);
|
|
return newRoot;
|
|
}
|
|
}, {
|
|
key: "checkExtendsForNonMatched",
|
|
value: function checkExtendsForNonMatched(extendList) {
|
|
var indices = this.extendIndices;
|
|
extendList.filter(function (extend) {
|
|
return !extend.hasFoundMatches && extend.parent_ids.length == 1;
|
|
}).forEach(function (extend) {
|
|
var selector = '_unknown_';
|
|
|
|
try {
|
|
selector = extend.selector.toCSS({});
|
|
} catch (_) {}
|
|
|
|
if (!indices[`${extend.index} ${selector}`]) {
|
|
indices[`${extend.index} ${selector}`] = true;
|
|
logger.warn(`extend '${selector}' has no matches`);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "doExtendChaining",
|
|
value: function doExtendChaining(extendsList, extendsListTarget, iterationCount) {
|
|
//
|
|
// chaining is different from normal extension.. if we extend an extend then we are not just copying, altering
|
|
// and pasting the selector we would do normally, but we are also adding an extend with the same target selector
|
|
// this means this new extend can then go and alter other extends
|
|
//
|
|
// this method deals with all the chaining work - without it, extend is flat and doesn't work on other extend selectors
|
|
// this is also the most expensive.. and a match on one selector can cause an extension of a selector we had already
|
|
// processed if we look at each selector at a time, as is done in visitRuleset
|
|
var extendIndex;
|
|
var targetExtendIndex;
|
|
var matches;
|
|
var extendsToAdd = [];
|
|
var newSelector;
|
|
var extendVisitor = this;
|
|
var selectorPath;
|
|
var extend;
|
|
var targetExtend;
|
|
var newExtend;
|
|
iterationCount = iterationCount || 0; // loop through comparing every extend with every target extend.
|
|
// a target extend is the one on the ruleset we are looking at copy/edit/pasting in place
|
|
// e.g. .a:extend(.b) {} and .b:extend(.c) {} then the first extend extends the second one
|
|
// and the second is the target.
|
|
// the separation into two lists allows us to process a subset of chains with a bigger set, as is the
|
|
// case when processing media queries
|
|
|
|
for (extendIndex = 0; extendIndex < extendsList.length; extendIndex++) {
|
|
for (targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++) {
|
|
extend = extendsList[extendIndex];
|
|
targetExtend = extendsListTarget[targetExtendIndex]; // look for circular references
|
|
|
|
if (extend.parent_ids.indexOf(targetExtend.object_id) >= 0) {
|
|
continue;
|
|
} // find a match in the target extends self selector (the bit before :extend)
|
|
|
|
|
|
selectorPath = [targetExtend.selfSelectors[0]];
|
|
matches = extendVisitor.findMatch(extend, selectorPath);
|
|
|
|
if (matches.length) {
|
|
extend.hasFoundMatches = true; // we found a match, so for each self selector..
|
|
|
|
extend.selfSelectors.forEach(function (selfSelector) {
|
|
var info = targetExtend.visibilityInfo(); // process the extend as usual
|
|
|
|
newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector, extend.isVisible()); // but now we create a new extend from it
|
|
|
|
newExtend = new tree.Extend(targetExtend.selector, targetExtend.option, 0, targetExtend.fileInfo(), info);
|
|
newExtend.selfSelectors = newSelector; // add the extend onto the list of extends for that selector
|
|
|
|
newSelector[newSelector.length - 1].extendList = [newExtend]; // record that we need to add it.
|
|
|
|
extendsToAdd.push(newExtend);
|
|
newExtend.ruleset = targetExtend.ruleset; // remember its parents for circular references
|
|
|
|
newExtend.parent_ids = newExtend.parent_ids.concat(targetExtend.parent_ids, extend.parent_ids); // only process the selector once.. if we have :extend(.a,.b) then multiple
|
|
// extends will look at the same selector path, so when extending
|
|
// we know that any others will be duplicates in terms of what is added to the css
|
|
|
|
if (targetExtend.firstExtendOnThisSelectorPath) {
|
|
newExtend.firstExtendOnThisSelectorPath = true;
|
|
targetExtend.ruleset.paths.push(newSelector);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (extendsToAdd.length) {
|
|
// try to detect circular references to stop a stack overflow.
|
|
// may no longer be needed.
|
|
this.extendChainCount++;
|
|
|
|
if (iterationCount > 100) {
|
|
var selectorOne = '{unable to calculate}';
|
|
var selectorTwo = '{unable to calculate}';
|
|
|
|
try {
|
|
selectorOne = extendsToAdd[0].selfSelectors[0].toCSS();
|
|
selectorTwo = extendsToAdd[0].selector.toCSS();
|
|
} catch (e) {}
|
|
|
|
throw {
|
|
message: `extend circular reference detected. One of the circular extends is currently:${selectorOne}:extend(${selectorTwo})`
|
|
};
|
|
} // now process the new extends on the existing rules so that we can handle a extending b extending c extending
|
|
// d extending e...
|
|
|
|
|
|
return extendsToAdd.concat(extendVisitor.doExtendChaining(extendsToAdd, extendsListTarget, iterationCount + 1));
|
|
} else {
|
|
return extendsToAdd;
|
|
}
|
|
}
|
|
}, {
|
|
key: "visitDeclaration",
|
|
value: function visitDeclaration(ruleNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitMixinDefinition",
|
|
value: function visitMixinDefinition(mixinDefinitionNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitSelector",
|
|
value: function visitSelector(selectorNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitRuleset",
|
|
value: function visitRuleset(rulesetNode, visitArgs) {
|
|
if (rulesetNode.root) {
|
|
return;
|
|
}
|
|
|
|
var matches;
|
|
var pathIndex;
|
|
var extendIndex;
|
|
var allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];
|
|
var selectorsToAdd = [];
|
|
var extendVisitor = this;
|
|
var selectorPath; // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
|
|
|
|
for (extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
|
|
for (pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
|
|
selectorPath = rulesetNode.paths[pathIndex]; // extending extends happens initially, before the main pass
|
|
|
|
if (rulesetNode.extendOnEveryPath) {
|
|
continue;
|
|
}
|
|
|
|
var extendList = selectorPath[selectorPath.length - 1].extendList;
|
|
|
|
if (extendList && extendList.length) {
|
|
continue;
|
|
}
|
|
|
|
matches = this.findMatch(allExtends[extendIndex], selectorPath);
|
|
|
|
if (matches.length) {
|
|
allExtends[extendIndex].hasFoundMatches = true;
|
|
allExtends[extendIndex].selfSelectors.forEach(function (selfSelector) {
|
|
var extendedSelectors;
|
|
extendedSelectors = extendVisitor.extendSelector(matches, selectorPath, selfSelector, allExtends[extendIndex].isVisible());
|
|
selectorsToAdd.push(extendedSelectors);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
rulesetNode.paths = rulesetNode.paths.concat(selectorsToAdd);
|
|
}
|
|
}, {
|
|
key: "findMatch",
|
|
value: function findMatch(extend, haystackSelectorPath) {
|
|
//
|
|
// look through the haystack selector path to try and find the needle - extend.selector
|
|
// returns an array of selector matches that can then be replaced
|
|
//
|
|
var haystackSelectorIndex;
|
|
var hackstackSelector;
|
|
var hackstackElementIndex;
|
|
var haystackElement;
|
|
var targetCombinator;
|
|
var i;
|
|
var extendVisitor = this;
|
|
var needleElements = extend.selector.elements;
|
|
var potentialMatches = [];
|
|
var potentialMatch;
|
|
var matches = []; // loop through the haystack elements
|
|
|
|
for (haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
|
|
hackstackSelector = haystackSelectorPath[haystackSelectorIndex];
|
|
|
|
for (hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
|
|
haystackElement = hackstackSelector.elements[hackstackElementIndex]; // if we allow elements before our match we can add a potential match every time. otherwise only at the first element.
|
|
|
|
if (extend.allowBefore || haystackSelectorIndex === 0 && hackstackElementIndex === 0) {
|
|
potentialMatches.push({
|
|
pathIndex: haystackSelectorIndex,
|
|
index: hackstackElementIndex,
|
|
matched: 0,
|
|
initialCombinator: haystackElement.combinator
|
|
});
|
|
}
|
|
|
|
for (i = 0; i < potentialMatches.length; i++) {
|
|
potentialMatch = potentialMatches[i]; // selectors add " " onto the first element. When we use & it joins the selectors together, but if we don't
|
|
// then each selector in haystackSelectorPath has a space before it added in the toCSS phase. so we need to
|
|
// work out what the resulting combinator will be
|
|
|
|
targetCombinator = haystackElement.combinator.value;
|
|
|
|
if (targetCombinator === '' && hackstackElementIndex === 0) {
|
|
targetCombinator = ' ';
|
|
} // if we don't match, null our match to indicate failure
|
|
|
|
|
|
if (!extendVisitor.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) || potentialMatch.matched > 0 && needleElements[potentialMatch.matched].combinator.value !== targetCombinator) {
|
|
potentialMatch = null;
|
|
} else {
|
|
potentialMatch.matched++;
|
|
} // if we are still valid and have finished, test whether we have elements after and whether these are allowed
|
|
|
|
|
|
if (potentialMatch) {
|
|
potentialMatch.finished = potentialMatch.matched === needleElements.length;
|
|
|
|
if (potentialMatch.finished && !extend.allowAfter && (hackstackElementIndex + 1 < hackstackSelector.elements.length || haystackSelectorIndex + 1 < haystackSelectorPath.length)) {
|
|
potentialMatch = null;
|
|
}
|
|
} // if null we remove, if not, we are still valid, so either push as a valid match or continue
|
|
|
|
|
|
if (potentialMatch) {
|
|
if (potentialMatch.finished) {
|
|
potentialMatch.length = needleElements.length;
|
|
potentialMatch.endPathIndex = haystackSelectorIndex;
|
|
potentialMatch.endPathElementIndex = hackstackElementIndex + 1; // index after end of match
|
|
|
|
potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again
|
|
|
|
matches.push(potentialMatch);
|
|
}
|
|
} else {
|
|
potentialMatches.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return matches;
|
|
}
|
|
}, {
|
|
key: "isElementValuesEqual",
|
|
value: function isElementValuesEqual(elementValue1, elementValue2) {
|
|
if (typeof elementValue1 === 'string' || typeof elementValue2 === 'string') {
|
|
return elementValue1 === elementValue2;
|
|
}
|
|
|
|
if (elementValue1 instanceof tree.Attribute) {
|
|
if (elementValue1.op !== elementValue2.op || elementValue1.key !== elementValue2.key) {
|
|
return false;
|
|
}
|
|
|
|
if (!elementValue1.value || !elementValue2.value) {
|
|
if (elementValue1.value || elementValue2.value) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
elementValue1 = elementValue1.value.value || elementValue1.value;
|
|
elementValue2 = elementValue2.value.value || elementValue2.value;
|
|
return elementValue1 === elementValue2;
|
|
}
|
|
|
|
elementValue1 = elementValue1.value;
|
|
elementValue2 = elementValue2.value;
|
|
|
|
if (elementValue1 instanceof tree.Selector) {
|
|
if (!(elementValue2 instanceof tree.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0; i < elementValue1.elements.length; i++) {
|
|
if (elementValue1.elements[i].combinator.value !== elementValue2.elements[i].combinator.value) {
|
|
if (i !== 0 || (elementValue1.elements[i].combinator.value || ' ') !== (elementValue2.elements[i].combinator.value || ' ')) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!this.isElementValuesEqual(elementValue1.elements[i].value, elementValue2.elements[i].value)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "extendSelector",
|
|
value: function extendSelector(matches, selectorPath, replacementSelector, isVisible) {
|
|
// for a set of matches, replace each match with the replacement selector
|
|
var currentSelectorPathIndex = 0;
|
|
var currentSelectorPathElementIndex = 0;
|
|
var path = [];
|
|
var matchIndex;
|
|
var selector;
|
|
var firstElement;
|
|
var match;
|
|
var newElements;
|
|
|
|
for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {
|
|
match = matches[matchIndex];
|
|
selector = selectorPath[match.pathIndex];
|
|
firstElement = new tree.Element(match.initialCombinator, replacementSelector.elements[0].value, replacementSelector.elements[0].isVariable, replacementSelector.elements[0].getIndex(), replacementSelector.elements[0].fileInfo());
|
|
|
|
if (match.pathIndex > currentSelectorPathIndex && currentSelectorPathElementIndex > 0) {
|
|
path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
|
|
currentSelectorPathElementIndex = 0;
|
|
currentSelectorPathIndex++;
|
|
}
|
|
|
|
newElements = selector.elements.slice(currentSelectorPathElementIndex, match.index).concat([firstElement]).concat(replacementSelector.elements.slice(1));
|
|
|
|
if (currentSelectorPathIndex === match.pathIndex && matchIndex > 0) {
|
|
path[path.length - 1].elements = path[path.length - 1].elements.concat(newElements);
|
|
} else {
|
|
path = path.concat(selectorPath.slice(currentSelectorPathIndex, match.pathIndex));
|
|
path.push(new tree.Selector(newElements));
|
|
}
|
|
|
|
currentSelectorPathIndex = match.endPathIndex;
|
|
currentSelectorPathElementIndex = match.endPathElementIndex;
|
|
|
|
if (currentSelectorPathElementIndex >= selectorPath[currentSelectorPathIndex].elements.length) {
|
|
currentSelectorPathElementIndex = 0;
|
|
currentSelectorPathIndex++;
|
|
}
|
|
}
|
|
|
|
if (currentSelectorPathIndex < selectorPath.length && currentSelectorPathElementIndex > 0) {
|
|
path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
|
|
currentSelectorPathIndex++;
|
|
}
|
|
|
|
path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
|
|
path = path.map(function (currentValue) {
|
|
// we can re-use elements here, because the visibility property matters only for selectors
|
|
var derived = currentValue.createDerived(currentValue.elements);
|
|
|
|
if (isVisible) {
|
|
derived.ensureVisibility();
|
|
} else {
|
|
derived.ensureInvisibility();
|
|
}
|
|
|
|
return derived;
|
|
});
|
|
return path;
|
|
}
|
|
}, {
|
|
key: "visitMedia",
|
|
value: function visitMedia(mediaNode, visitArgs) {
|
|
var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
|
|
newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
|
|
this.allExtendsStack.push(newAllExtends);
|
|
}
|
|
}, {
|
|
key: "visitMediaOut",
|
|
value: function visitMediaOut(mediaNode) {
|
|
var lastIndex = this.allExtendsStack.length - 1;
|
|
this.allExtendsStack.length = lastIndex;
|
|
}
|
|
}, {
|
|
key: "visitAtRule",
|
|
value: function visitAtRule(atRuleNode, visitArgs) {
|
|
var newAllExtends = atRuleNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
|
|
newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, atRuleNode.allExtends));
|
|
this.allExtendsStack.push(newAllExtends);
|
|
}
|
|
}, {
|
|
key: "visitAtRuleOut",
|
|
value: function visitAtRuleOut(atRuleNode) {
|
|
var lastIndex = this.allExtendsStack.length - 1;
|
|
this.allExtendsStack.length = lastIndex;
|
|
}
|
|
}]);
|
|
|
|
return ProcessExtendsVisitor;
|
|
}();
|
|
|
|
var JoinSelectorVisitor =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function JoinSelectorVisitor() {
|
|
_classCallCheck(this, JoinSelectorVisitor);
|
|
|
|
this.contexts = [[]];
|
|
this._visitor = new Visitor(this);
|
|
}
|
|
|
|
_createClass(JoinSelectorVisitor, [{
|
|
key: "run",
|
|
value: function run(root) {
|
|
return this._visitor.visit(root);
|
|
}
|
|
}, {
|
|
key: "visitDeclaration",
|
|
value: function visitDeclaration(declNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitMixinDefinition",
|
|
value: function visitMixinDefinition(mixinDefinitionNode, visitArgs) {
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
}, {
|
|
key: "visitRuleset",
|
|
value: function visitRuleset(rulesetNode, visitArgs) {
|
|
var context = this.contexts[this.contexts.length - 1];
|
|
var paths = [];
|
|
var selectors;
|
|
this.contexts.push(paths);
|
|
|
|
if (!rulesetNode.root) {
|
|
selectors = rulesetNode.selectors;
|
|
|
|
if (selectors) {
|
|
selectors = selectors.filter(function (selector) {
|
|
return selector.getIsOutput();
|
|
});
|
|
rulesetNode.selectors = selectors.length ? selectors : selectors = null;
|
|
|
|
if (selectors) {
|
|
rulesetNode.joinSelectors(paths, context, selectors);
|
|
}
|
|
}
|
|
|
|
if (!selectors) {
|
|
rulesetNode.rules = null;
|
|
}
|
|
|
|
rulesetNode.paths = paths;
|
|
}
|
|
}
|
|
}, {
|
|
key: "visitRulesetOut",
|
|
value: function visitRulesetOut(rulesetNode) {
|
|
this.contexts.length = this.contexts.length - 1;
|
|
}
|
|
}, {
|
|
key: "visitMedia",
|
|
value: function visitMedia(mediaNode, visitArgs) {
|
|
var context = this.contexts[this.contexts.length - 1];
|
|
mediaNode.rules[0].root = context.length === 0 || context[0].multiMedia;
|
|
}
|
|
}, {
|
|
key: "visitAtRule",
|
|
value: function visitAtRule(atRuleNode, visitArgs) {
|
|
var context = this.contexts[this.contexts.length - 1];
|
|
|
|
if (atRuleNode.rules && atRuleNode.rules.length) {
|
|
atRuleNode.rules[0].root = atRuleNode.isRooted || context.length === 0 || null;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return JoinSelectorVisitor;
|
|
}();
|
|
|
|
var CSSVisitorUtils =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function CSSVisitorUtils(context) {
|
|
_classCallCheck(this, CSSVisitorUtils);
|
|
|
|
this._visitor = new Visitor(this);
|
|
this._context = context;
|
|
}
|
|
|
|
_createClass(CSSVisitorUtils, [{
|
|
key: "containsSilentNonBlockedChild",
|
|
value: function containsSilentNonBlockedChild(bodyRules) {
|
|
var rule;
|
|
|
|
if (!bodyRules) {
|
|
return false;
|
|
}
|
|
|
|
for (var r = 0; r < bodyRules.length; r++) {
|
|
rule = bodyRules[r];
|
|
|
|
if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {
|
|
// the atrule contains something that was referenced (likely by extend)
|
|
// therefore it needs to be shown in output too
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "keepOnlyVisibleChilds",
|
|
value: function keepOnlyVisibleChilds(owner) {
|
|
if (owner && owner.rules) {
|
|
owner.rules = owner.rules.filter(function (thing) {
|
|
return thing.isVisible();
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty(owner) {
|
|
return owner && owner.rules ? owner.rules.length === 0 : true;
|
|
}
|
|
}, {
|
|
key: "hasVisibleSelector",
|
|
value: function hasVisibleSelector(rulesetNode) {
|
|
return rulesetNode && rulesetNode.paths ? rulesetNode.paths.length > 0 : false;
|
|
}
|
|
}, {
|
|
key: "resolveVisibility",
|
|
value: function resolveVisibility(node, originalRules) {
|
|
if (!node.blocksVisibility()) {
|
|
if (this.isEmpty(node) && !this.containsSilentNonBlockedChild(originalRules)) {
|
|
return;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
var compiledRulesBody = node.rules[0];
|
|
this.keepOnlyVisibleChilds(compiledRulesBody);
|
|
|
|
if (this.isEmpty(compiledRulesBody)) {
|
|
return;
|
|
}
|
|
|
|
node.ensureVisibility();
|
|
node.removeVisibilityBlock();
|
|
return node;
|
|
}
|
|
}, {
|
|
key: "isVisibleRuleset",
|
|
value: function isVisibleRuleset(rulesetNode) {
|
|
if (rulesetNode.firstRoot) {
|
|
return true;
|
|
}
|
|
|
|
if (this.isEmpty(rulesetNode)) {
|
|
return false;
|
|
}
|
|
|
|
if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}]);
|
|
|
|
return CSSVisitorUtils;
|
|
}();
|
|
|
|
var ToCSSVisitor = function ToCSSVisitor(context) {
|
|
this._visitor = new Visitor(this);
|
|
this._context = context;
|
|
this.utils = new CSSVisitorUtils(context);
|
|
};
|
|
|
|
ToCSSVisitor.prototype = {
|
|
isReplacing: true,
|
|
run: function run(root) {
|
|
return this._visitor.visit(root);
|
|
},
|
|
visitDeclaration: function visitDeclaration(declNode, visitArgs) {
|
|
if (declNode.blocksVisibility() || declNode.variable) {
|
|
return;
|
|
}
|
|
|
|
return declNode;
|
|
},
|
|
visitMixinDefinition: function visitMixinDefinition(mixinNode, visitArgs) {
|
|
// mixin definitions do not get eval'd - this means they keep state
|
|
// so we have to clear that state here so it isn't used if toCSS is called twice
|
|
mixinNode.frames = [];
|
|
},
|
|
visitExtend: function visitExtend(extendNode, visitArgs) {},
|
|
visitComment: function visitComment(commentNode, visitArgs) {
|
|
if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {
|
|
return;
|
|
}
|
|
|
|
return commentNode;
|
|
},
|
|
visitMedia: function visitMedia(mediaNode, visitArgs) {
|
|
var originalRules = mediaNode.rules[0].rules;
|
|
mediaNode.accept(this._visitor);
|
|
visitArgs.visitDeeper = false;
|
|
return this.utils.resolveVisibility(mediaNode, originalRules);
|
|
},
|
|
visitImport: function visitImport(importNode, visitArgs) {
|
|
if (importNode.blocksVisibility()) {
|
|
return;
|
|
}
|
|
|
|
return importNode;
|
|
},
|
|
visitAtRule: function visitAtRule(atRuleNode, visitArgs) {
|
|
if (atRuleNode.rules && atRuleNode.rules.length) {
|
|
return this.visitAtRuleWithBody(atRuleNode, visitArgs);
|
|
} else {
|
|
return this.visitAtRuleWithoutBody(atRuleNode, visitArgs);
|
|
}
|
|
},
|
|
visitAnonymous: function visitAnonymous(anonymousNode, visitArgs) {
|
|
if (!anonymousNode.blocksVisibility()) {
|
|
anonymousNode.accept(this._visitor);
|
|
return anonymousNode;
|
|
}
|
|
},
|
|
visitAtRuleWithBody: function visitAtRuleWithBody(atRuleNode, visitArgs) {
|
|
// if there is only one nested ruleset and that one has no path, then it is
|
|
// just fake ruleset
|
|
function hasFakeRuleset(atRuleNode) {
|
|
var bodyRules = atRuleNode.rules;
|
|
return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
|
|
}
|
|
|
|
function getBodyRules(atRuleNode) {
|
|
var nodeRules = atRuleNode.rules;
|
|
|
|
if (hasFakeRuleset(atRuleNode)) {
|
|
return nodeRules[0].rules;
|
|
}
|
|
|
|
return nodeRules;
|
|
} // it is still true that it is only one ruleset in array
|
|
// this is last such moment
|
|
// process childs
|
|
|
|
|
|
var originalRules = getBodyRules(atRuleNode);
|
|
atRuleNode.accept(this._visitor);
|
|
visitArgs.visitDeeper = false;
|
|
|
|
if (!this.utils.isEmpty(atRuleNode)) {
|
|
this._mergeRules(atRuleNode.rules[0].rules);
|
|
}
|
|
|
|
return this.utils.resolveVisibility(atRuleNode, originalRules);
|
|
},
|
|
visitAtRuleWithoutBody: function visitAtRuleWithoutBody(atRuleNode, visitArgs) {
|
|
if (atRuleNode.blocksVisibility()) {
|
|
return;
|
|
}
|
|
|
|
if (atRuleNode.name === '@charset') {
|
|
// Only output the debug info together with subsequent @charset definitions
|
|
// a comment (or @media statement) before the actual @charset atrule would
|
|
// be considered illegal css as it has to be on the first line
|
|
if (this.charset) {
|
|
if (atRuleNode.debugInfo) {
|
|
var comment = new tree.Comment(`/* ${atRuleNode.toCSS(this._context).replace(/\n/g, '')} */\n`);
|
|
comment.debugInfo = atRuleNode.debugInfo;
|
|
return this._visitor.visit(comment);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
this.charset = true;
|
|
}
|
|
|
|
return atRuleNode;
|
|
},
|
|
checkValidNodes: function checkValidNodes(rules, isRoot) {
|
|
if (!rules) {
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < rules.length; i++) {
|
|
var ruleNode = rules[i];
|
|
|
|
if (isRoot && ruleNode instanceof tree.Declaration && !ruleNode.variable) {
|
|
throw {
|
|
message: 'Properties must be inside selector blocks. They cannot be in the root',
|
|
index: ruleNode.getIndex(),
|
|
filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename
|
|
};
|
|
}
|
|
|
|
if (ruleNode instanceof tree.Call) {
|
|
throw {
|
|
message: `Function '${ruleNode.name}' is undefined`,
|
|
index: ruleNode.getIndex(),
|
|
filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename
|
|
};
|
|
}
|
|
|
|
if (ruleNode.type && !ruleNode.allowRoot) {
|
|
throw {
|
|
message: `${ruleNode.type} node returned by a function is not valid here`,
|
|
index: ruleNode.getIndex(),
|
|
filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename
|
|
};
|
|
}
|
|
}
|
|
},
|
|
visitRuleset: function visitRuleset(rulesetNode, visitArgs) {
|
|
// at this point rulesets are nested into each other
|
|
var rule;
|
|
var rulesets = [];
|
|
this.checkValidNodes(rulesetNode.rules, rulesetNode.firstRoot);
|
|
|
|
if (!rulesetNode.root) {
|
|
// remove invisible paths
|
|
this._compileRulesetPaths(rulesetNode); // remove rulesets from this ruleset body and compile them separately
|
|
|
|
|
|
var nodeRules = rulesetNode.rules;
|
|
var nodeRuleCnt = nodeRules ? nodeRules.length : 0;
|
|
|
|
for (var i = 0; i < nodeRuleCnt;) {
|
|
rule = nodeRules[i];
|
|
|
|
if (rule && rule.rules) {
|
|
// visit because we are moving them out from being a child
|
|
rulesets.push(this._visitor.visit(rule));
|
|
nodeRules.splice(i, 1);
|
|
nodeRuleCnt--;
|
|
continue;
|
|
}
|
|
|
|
i++;
|
|
} // accept the visitor to remove rules and refactor itself
|
|
// then we can decide nogw whether we want it or not
|
|
// compile body
|
|
|
|
|
|
if (nodeRuleCnt > 0) {
|
|
rulesetNode.accept(this._visitor);
|
|
} else {
|
|
rulesetNode.rules = null;
|
|
}
|
|
|
|
visitArgs.visitDeeper = false;
|
|
} else {
|
|
// if (! rulesetNode.root) {
|
|
rulesetNode.accept(this._visitor);
|
|
visitArgs.visitDeeper = false;
|
|
}
|
|
|
|
if (rulesetNode.rules) {
|
|
this._mergeRules(rulesetNode.rules);
|
|
|
|
this._removeDuplicateRules(rulesetNode.rules);
|
|
} // now decide whether we keep the ruleset
|
|
|
|
|
|
if (this.utils.isVisibleRuleset(rulesetNode)) {
|
|
rulesetNode.ensureVisibility();
|
|
rulesets.splice(0, 0, rulesetNode);
|
|
}
|
|
|
|
if (rulesets.length === 1) {
|
|
return rulesets[0];
|
|
}
|
|
|
|
return rulesets;
|
|
},
|
|
_compileRulesetPaths: function _compileRulesetPaths(rulesetNode) {
|
|
if (rulesetNode.paths) {
|
|
rulesetNode.paths = rulesetNode.paths.filter(function (p) {
|
|
var i;
|
|
|
|
if (p[0].elements[0].combinator.value === ' ') {
|
|
p[0].elements[0].combinator = new tree.Combinator('');
|
|
}
|
|
|
|
for (i = 0; i < p.length; i++) {
|
|
if (p[i].isVisible() && p[i].getIsOutput()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
});
|
|
}
|
|
},
|
|
_removeDuplicateRules: function _removeDuplicateRules(rules) {
|
|
if (!rules) {
|
|
return;
|
|
} // remove duplicates
|
|
|
|
|
|
var ruleCache = {};
|
|
var ruleList;
|
|
var rule;
|
|
var i;
|
|
|
|
for (i = rules.length - 1; i >= 0; i--) {
|
|
rule = rules[i];
|
|
|
|
if (rule instanceof tree.Declaration) {
|
|
if (!ruleCache[rule.name]) {
|
|
ruleCache[rule.name] = rule;
|
|
} else {
|
|
ruleList = ruleCache[rule.name];
|
|
|
|
if (ruleList instanceof tree.Declaration) {
|
|
ruleList = ruleCache[rule.name] = [ruleCache[rule.name].toCSS(this._context)];
|
|
}
|
|
|
|
var ruleCSS = rule.toCSS(this._context);
|
|
|
|
if (ruleList.indexOf(ruleCSS) !== -1) {
|
|
rules.splice(i, 1);
|
|
} else {
|
|
ruleList.push(ruleCSS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
_mergeRules: function _mergeRules(rules) {
|
|
if (!rules) {
|
|
return;
|
|
}
|
|
|
|
var groups = {};
|
|
var groupsArr = [];
|
|
|
|
for (var i = 0; i < rules.length; i++) {
|
|
var rule = rules[i];
|
|
|
|
if (rule.merge) {
|
|
var key = rule.name;
|
|
groups[key] ? rules.splice(i--, 1) : groupsArr.push(groups[key] = []);
|
|
groups[key].push(rule);
|
|
}
|
|
}
|
|
|
|
groupsArr.forEach(function (group) {
|
|
if (group.length > 0) {
|
|
var result = group[0];
|
|
var space = [];
|
|
var comma = [new tree.Expression(space)];
|
|
group.forEach(function (rule) {
|
|
if (rule.merge === '+' && space.length > 0) {
|
|
comma.push(new tree.Expression(space = []));
|
|
}
|
|
|
|
space.push(rule.value);
|
|
result.important = result.important || rule.important;
|
|
});
|
|
result.value = new tree.Value(comma);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
var visitors = {
|
|
Visitor,
|
|
ImportVisitor,
|
|
MarkVisibleSelectorsVisitor: SetTreeVisibilityVisitor,
|
|
ExtendVisitor: ProcessExtendsVisitor,
|
|
JoinSelectorVisitor,
|
|
ToCSSVisitor
|
|
};
|
|
|
|
// Split the input into chunks.
|
|
var chunker = (function (input, fail) {
|
|
var len = input.length;
|
|
var level = 0;
|
|
var parenLevel = 0;
|
|
var lastOpening;
|
|
var lastOpeningParen;
|
|
var lastMultiComment;
|
|
var lastMultiCommentEndBrace;
|
|
var chunks = [];
|
|
var emitFrom = 0;
|
|
var chunkerCurrentIndex;
|
|
var currentChunkStartIndex;
|
|
var cc;
|
|
var cc2;
|
|
var matched;
|
|
|
|
function emitChunk(force) {
|
|
var len = chunkerCurrentIndex - emitFrom;
|
|
|
|
if (len < 512 && !force || !len) {
|
|
return;
|
|
}
|
|
|
|
chunks.push(input.slice(emitFrom, chunkerCurrentIndex + 1));
|
|
emitFrom = chunkerCurrentIndex + 1;
|
|
}
|
|
|
|
for (chunkerCurrentIndex = 0; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
|
|
cc = input.charCodeAt(chunkerCurrentIndex);
|
|
|
|
if (cc >= 97 && cc <= 122 || cc < 34) {
|
|
// a-z or whitespace
|
|
continue;
|
|
}
|
|
|
|
switch (cc) {
|
|
case 40:
|
|
// (
|
|
parenLevel++;
|
|
lastOpeningParen = chunkerCurrentIndex;
|
|
continue;
|
|
|
|
case 41:
|
|
// )
|
|
if (--parenLevel < 0) {
|
|
return fail('missing opening `(`', chunkerCurrentIndex);
|
|
}
|
|
|
|
continue;
|
|
|
|
case 59:
|
|
// ;
|
|
if (!parenLevel) {
|
|
emitChunk();
|
|
}
|
|
|
|
continue;
|
|
|
|
case 123:
|
|
// {
|
|
level++;
|
|
lastOpening = chunkerCurrentIndex;
|
|
continue;
|
|
|
|
case 125:
|
|
// }
|
|
if (--level < 0) {
|
|
return fail('missing opening `{`', chunkerCurrentIndex);
|
|
}
|
|
|
|
if (!level && !parenLevel) {
|
|
emitChunk();
|
|
}
|
|
|
|
continue;
|
|
|
|
case 92:
|
|
// \
|
|
if (chunkerCurrentIndex < len - 1) {
|
|
chunkerCurrentIndex++;
|
|
continue;
|
|
}
|
|
|
|
return fail('unescaped `\\`', chunkerCurrentIndex);
|
|
|
|
case 34:
|
|
case 39:
|
|
case 96:
|
|
// ", ' and `
|
|
matched = 0;
|
|
currentChunkStartIndex = chunkerCurrentIndex;
|
|
|
|
for (chunkerCurrentIndex = chunkerCurrentIndex + 1; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
|
|
cc2 = input.charCodeAt(chunkerCurrentIndex);
|
|
|
|
if (cc2 > 96) {
|
|
continue;
|
|
}
|
|
|
|
if (cc2 == cc) {
|
|
matched = 1;
|
|
break;
|
|
}
|
|
|
|
if (cc2 == 92) {
|
|
// \
|
|
if (chunkerCurrentIndex == len - 1) {
|
|
return fail('unescaped `\\`', chunkerCurrentIndex);
|
|
}
|
|
|
|
chunkerCurrentIndex++;
|
|
}
|
|
}
|
|
|
|
if (matched) {
|
|
continue;
|
|
}
|
|
|
|
return fail(`unmatched \`${String.fromCharCode(cc)}\``, currentChunkStartIndex);
|
|
|
|
case 47:
|
|
// /, check for comment
|
|
if (parenLevel || chunkerCurrentIndex == len - 1) {
|
|
continue;
|
|
}
|
|
|
|
cc2 = input.charCodeAt(chunkerCurrentIndex + 1);
|
|
|
|
if (cc2 == 47) {
|
|
// //, find lnfeed
|
|
for (chunkerCurrentIndex = chunkerCurrentIndex + 2; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
|
|
cc2 = input.charCodeAt(chunkerCurrentIndex);
|
|
|
|
if (cc2 <= 13 && (cc2 == 10 || cc2 == 13)) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (cc2 == 42) {
|
|
// /*, find */
|
|
lastMultiComment = currentChunkStartIndex = chunkerCurrentIndex;
|
|
|
|
for (chunkerCurrentIndex = chunkerCurrentIndex + 2; chunkerCurrentIndex < len - 1; chunkerCurrentIndex++) {
|
|
cc2 = input.charCodeAt(chunkerCurrentIndex);
|
|
|
|
if (cc2 == 125) {
|
|
lastMultiCommentEndBrace = chunkerCurrentIndex;
|
|
}
|
|
|
|
if (cc2 != 42) {
|
|
continue;
|
|
}
|
|
|
|
if (input.charCodeAt(chunkerCurrentIndex + 1) == 47) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (chunkerCurrentIndex == len - 1) {
|
|
return fail('missing closing `*/`', currentChunkStartIndex);
|
|
}
|
|
|
|
chunkerCurrentIndex++;
|
|
}
|
|
|
|
continue;
|
|
|
|
case 42:
|
|
// *, check for unmatched */
|
|
if (chunkerCurrentIndex < len - 1 && input.charCodeAt(chunkerCurrentIndex + 1) == 47) {
|
|
return fail('unmatched `/*`', chunkerCurrentIndex);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (level !== 0) {
|
|
if (lastMultiComment > lastOpening && lastMultiCommentEndBrace > lastMultiComment) {
|
|
return fail('missing closing `}` or `*/`', lastOpening);
|
|
} else {
|
|
return fail('missing closing `}`', lastOpening);
|
|
}
|
|
} else if (parenLevel !== 0) {
|
|
return fail('missing closing `)`', lastOpeningParen);
|
|
}
|
|
|
|
emitChunk(true);
|
|
return chunks;
|
|
});
|
|
|
|
var getParserInput = (function () {
|
|
var // Less input string
|
|
input;
|
|
var // current chunk
|
|
j;
|
|
var // holds state for backtracking
|
|
saveStack = [];
|
|
var // furthest index the parser has gone to
|
|
furthest;
|
|
var // if this is furthest we got to, this is the probably cause
|
|
furthestPossibleErrorMessage;
|
|
var // chunkified input
|
|
chunks;
|
|
var // current chunk
|
|
current;
|
|
var // index of current chunk, in `input`
|
|
currentPos;
|
|
var parserInput = {};
|
|
var CHARCODE_SPACE = 32;
|
|
var CHARCODE_TAB = 9;
|
|
var CHARCODE_LF = 10;
|
|
var CHARCODE_CR = 13;
|
|
var CHARCODE_PLUS = 43;
|
|
var CHARCODE_COMMA = 44;
|
|
var CHARCODE_FORWARD_SLASH = 47;
|
|
var CHARCODE_9 = 57;
|
|
|
|
function skipWhitespace(length) {
|
|
var oldi = parserInput.i;
|
|
var oldj = j;
|
|
var curr = parserInput.i - currentPos;
|
|
var endIndex = parserInput.i + current.length - curr;
|
|
var mem = parserInput.i += length;
|
|
var inp = input;
|
|
var c;
|
|
var nextChar;
|
|
var comment;
|
|
|
|
for (; parserInput.i < endIndex; parserInput.i++) {
|
|
c = inp.charCodeAt(parserInput.i);
|
|
|
|
if (parserInput.autoCommentAbsorb && c === CHARCODE_FORWARD_SLASH) {
|
|
nextChar = inp.charAt(parserInput.i + 1);
|
|
|
|
if (nextChar === '/') {
|
|
comment = {
|
|
index: parserInput.i,
|
|
isLineComment: true
|
|
};
|
|
var nextNewLine = inp.indexOf('\n', parserInput.i + 2);
|
|
|
|
if (nextNewLine < 0) {
|
|
nextNewLine = endIndex;
|
|
}
|
|
|
|
parserInput.i = nextNewLine;
|
|
comment.text = inp.substr(comment.index, parserInput.i - comment.index);
|
|
parserInput.commentStore.push(comment);
|
|
continue;
|
|
} else if (nextChar === '*') {
|
|
var nextStarSlash = inp.indexOf('*/', parserInput.i + 2);
|
|
|
|
if (nextStarSlash >= 0) {
|
|
comment = {
|
|
index: parserInput.i,
|
|
text: inp.substr(parserInput.i, nextStarSlash + 2 - parserInput.i),
|
|
isLineComment: false
|
|
};
|
|
parserInput.i += comment.text.length - 1;
|
|
parserInput.commentStore.push(comment);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (c !== CHARCODE_SPACE && c !== CHARCODE_LF && c !== CHARCODE_TAB && c !== CHARCODE_CR) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
current = current.slice(length + parserInput.i - mem + curr);
|
|
currentPos = parserInput.i;
|
|
|
|
if (!current.length) {
|
|
if (j < chunks.length - 1) {
|
|
current = chunks[++j];
|
|
skipWhitespace(0); // skip space at the beginning of a chunk
|
|
|
|
return true; // things changed
|
|
}
|
|
|
|
parserInput.finished = true;
|
|
}
|
|
|
|
return oldi !== parserInput.i || oldj !== j;
|
|
}
|
|
|
|
parserInput.save = function () {
|
|
currentPos = parserInput.i;
|
|
saveStack.push({
|
|
current,
|
|
i: parserInput.i,
|
|
j
|
|
});
|
|
};
|
|
|
|
parserInput.restore = function (possibleErrorMessage) {
|
|
if (parserInput.i > furthest || parserInput.i === furthest && possibleErrorMessage && !furthestPossibleErrorMessage) {
|
|
furthest = parserInput.i;
|
|
furthestPossibleErrorMessage = possibleErrorMessage;
|
|
}
|
|
|
|
var state = saveStack.pop();
|
|
current = state.current;
|
|
currentPos = parserInput.i = state.i;
|
|
j = state.j;
|
|
};
|
|
|
|
parserInput.forget = function () {
|
|
saveStack.pop();
|
|
};
|
|
|
|
parserInput.isWhitespace = function (offset) {
|
|
var pos = parserInput.i + (offset || 0);
|
|
var code = input.charCodeAt(pos);
|
|
return code === CHARCODE_SPACE || code === CHARCODE_CR || code === CHARCODE_TAB || code === CHARCODE_LF;
|
|
}; // Specialization of $(tok)
|
|
|
|
|
|
parserInput.$re = function (tok) {
|
|
if (parserInput.i > currentPos) {
|
|
current = current.slice(parserInput.i - currentPos);
|
|
currentPos = parserInput.i;
|
|
}
|
|
|
|
var m = tok.exec(current);
|
|
|
|
if (!m) {
|
|
return null;
|
|
}
|
|
|
|
skipWhitespace(m[0].length);
|
|
|
|
if (typeof m === 'string') {
|
|
return m;
|
|
}
|
|
|
|
return m.length === 1 ? m[0] : m;
|
|
};
|
|
|
|
parserInput.$char = function (tok) {
|
|
if (input.charAt(parserInput.i) !== tok) {
|
|
return null;
|
|
}
|
|
|
|
skipWhitespace(1);
|
|
return tok;
|
|
};
|
|
|
|
parserInput.$str = function (tok) {
|
|
var tokLength = tok.length; // https://jsperf.com/string-startswith/21
|
|
|
|
for (var i = 0; i < tokLength; i++) {
|
|
if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
skipWhitespace(tokLength);
|
|
return tok;
|
|
};
|
|
|
|
parserInput.$quoted = function (loc) {
|
|
var pos = loc || parserInput.i;
|
|
var startChar = input.charAt(pos);
|
|
|
|
if (startChar !== '\'' && startChar !== '"') {
|
|
return;
|
|
}
|
|
|
|
var length = input.length;
|
|
var currentPosition = pos;
|
|
|
|
for (var i = 1; i + currentPosition < length; i++) {
|
|
var nextChar = input.charAt(i + currentPosition);
|
|
|
|
switch (nextChar) {
|
|
case '\\':
|
|
i++;
|
|
continue;
|
|
|
|
case '\r':
|
|
case '\n':
|
|
break;
|
|
|
|
case startChar:
|
|
var str = input.substr(currentPosition, i + 1);
|
|
|
|
if (!loc && loc !== 0) {
|
|
skipWhitespace(i + 1);
|
|
return str;
|
|
}
|
|
|
|
return [startChar, str];
|
|
|
|
default:
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
/**
|
|
* Permissive parsing. Ignores everything except matching {} [] () and quotes
|
|
* until matching token (outside of blocks)
|
|
*/
|
|
|
|
|
|
parserInput.$parseUntil = function (tok) {
|
|
var quote = '';
|
|
var returnVal = null;
|
|
var inComment = false;
|
|
var blockDepth = 0;
|
|
var blockStack = [];
|
|
var parseGroups = [];
|
|
var length = input.length;
|
|
var startPos = parserInput.i;
|
|
var lastPos = parserInput.i;
|
|
var i = parserInput.i;
|
|
var loop = true;
|
|
var testChar;
|
|
|
|
if (typeof tok === 'string') {
|
|
testChar = function testChar(char) {
|
|
return char === tok;
|
|
};
|
|
} else {
|
|
testChar = function testChar(char) {
|
|
return tok.test(char);
|
|
};
|
|
}
|
|
|
|
do {
|
|
var nextChar = input.charAt(i);
|
|
|
|
if (blockDepth === 0 && testChar(nextChar)) {
|
|
returnVal = input.substr(lastPos, i - lastPos);
|
|
|
|
if (returnVal) {
|
|
parseGroups.push(returnVal);
|
|
} else {
|
|
parseGroups.push(' ');
|
|
}
|
|
|
|
returnVal = parseGroups;
|
|
skipWhitespace(i - startPos);
|
|
loop = false;
|
|
} else {
|
|
if (inComment) {
|
|
if (nextChar === '*' && input.charAt(i + 1) === '/') {
|
|
i++;
|
|
blockDepth--;
|
|
inComment = false;
|
|
}
|
|
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
switch (nextChar) {
|
|
case '\\':
|
|
i++;
|
|
nextChar = input.charAt(i);
|
|
parseGroups.push(input.substr(lastPos, i - lastPos + 1));
|
|
lastPos = i + 1;
|
|
break;
|
|
|
|
case '/':
|
|
if (input.charAt(i + 1) === '*') {
|
|
i++;
|
|
inComment = true;
|
|
blockDepth++;
|
|
}
|
|
|
|
break;
|
|
|
|
case '\'':
|
|
case '"':
|
|
quote = parserInput.$quoted(i);
|
|
|
|
if (quote) {
|
|
parseGroups.push(input.substr(lastPos, i - lastPos), quote);
|
|
i += quote[1].length - 1;
|
|
lastPos = i + 1;
|
|
} else {
|
|
skipWhitespace(i - startPos);
|
|
returnVal = nextChar;
|
|
loop = false;
|
|
}
|
|
|
|
break;
|
|
|
|
case '{':
|
|
blockStack.push('}');
|
|
blockDepth++;
|
|
break;
|
|
|
|
case '(':
|
|
blockStack.push(')');
|
|
blockDepth++;
|
|
break;
|
|
|
|
case '[':
|
|
blockStack.push(']');
|
|
blockDepth++;
|
|
break;
|
|
|
|
case '}':
|
|
case ')':
|
|
case ']':
|
|
var expected = blockStack.pop();
|
|
|
|
if (nextChar === expected) {
|
|
blockDepth--;
|
|
} else {
|
|
// move the parser to the error and return expected
|
|
skipWhitespace(i - startPos);
|
|
returnVal = expected;
|
|
loop = false;
|
|
}
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
if (i > length) {
|
|
loop = false;
|
|
}
|
|
}
|
|
} while (loop);
|
|
|
|
return returnVal ? returnVal : null;
|
|
};
|
|
|
|
parserInput.autoCommentAbsorb = true;
|
|
parserInput.commentStore = [];
|
|
parserInput.finished = false; // Same as $(), but don't change the state of the parser,
|
|
// just return the match.
|
|
|
|
parserInput.peek = function (tok) {
|
|
if (typeof tok === 'string') {
|
|
// https://jsperf.com/string-startswith/21
|
|
for (var i = 0; i < tok.length; i++) {
|
|
if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return tok.test(current);
|
|
}
|
|
}; // Specialization of peek()
|
|
// TODO remove or change some currentChar calls to peekChar
|
|
|
|
|
|
parserInput.peekChar = function (tok) {
|
|
return input.charAt(parserInput.i) === tok;
|
|
};
|
|
|
|
parserInput.currentChar = function () {
|
|
return input.charAt(parserInput.i);
|
|
};
|
|
|
|
parserInput.prevChar = function () {
|
|
return input.charAt(parserInput.i - 1);
|
|
};
|
|
|
|
parserInput.getInput = function () {
|
|
return input;
|
|
};
|
|
|
|
parserInput.peekNotNumeric = function () {
|
|
var c = input.charCodeAt(parserInput.i); // Is the first char of the dimension 0-9, '.', '+' or '-'
|
|
|
|
return c > CHARCODE_9 || c < CHARCODE_PLUS || c === CHARCODE_FORWARD_SLASH || c === CHARCODE_COMMA;
|
|
};
|
|
|
|
parserInput.start = function (str, chunkInput, failFunction) {
|
|
input = str;
|
|
parserInput.i = j = currentPos = furthest = 0; // chunking apparently makes things quicker (but my tests indicate
|
|
// it might actually make things slower in node at least)
|
|
// and it is a non-perfect parse - it can't recognise
|
|
// unquoted urls, meaning it can't distinguish comments
|
|
// meaning comments with quotes or {}() in them get 'counted'
|
|
// and then lead to parse errors.
|
|
// In addition if the chunking chunks in the wrong place we might
|
|
// not be able to parse a parser statement in one go
|
|
// this is officially deprecated but can be switched on via an option
|
|
// in the case it causes too much performance issues.
|
|
|
|
if (chunkInput) {
|
|
chunks = chunker(str, failFunction);
|
|
} else {
|
|
chunks = [str];
|
|
}
|
|
|
|
current = chunks[0];
|
|
skipWhitespace(0);
|
|
};
|
|
|
|
parserInput.end = function () {
|
|
var message;
|
|
var isFinished = parserInput.i >= input.length;
|
|
|
|
if (parserInput.i < furthest) {
|
|
message = furthestPossibleErrorMessage;
|
|
parserInput.i = furthest;
|
|
}
|
|
|
|
return {
|
|
isFinished,
|
|
furthest: parserInput.i,
|
|
furthestPossibleErrorMessage: message,
|
|
furthestReachedEnd: parserInput.i >= input.length - 1,
|
|
furthestChar: input[parserInput.i]
|
|
};
|
|
};
|
|
|
|
return parserInput;
|
|
});
|
|
|
|
// less.js - parser
|
|
//
|
|
// A relatively straight-forward predictive parser.
|
|
// There is no tokenization/lexing stage, the input is parsed
|
|
// in one sweep.
|
|
//
|
|
// To make the parser fast enough to run in the browser, several
|
|
// optimization had to be made:
|
|
//
|
|
// - Matching and slicing on a huge input is often cause of slowdowns.
|
|
// The solution is to chunkify the input into smaller strings.
|
|
// The chunks are stored in the `chunks` var,
|
|
// `j` holds the current chunk index, and `currentPos` holds
|
|
// the index of the current chunk in relation to `input`.
|
|
// This gives us an almost 4x speed-up.
|
|
//
|
|
// - In many cases, we don't need to match individual tokens;
|
|
// for example, if a value doesn't hold any variables, operations
|
|
// or dynamic references, the parser can effectively 'skip' it,
|
|
// treating it as a literal.
|
|
// An example would be '1px solid #000' - which evaluates to itself,
|
|
// we don't need to know what the individual components are.
|
|
// The drawback, of course is that you don't get the benefits of
|
|
// syntax-checking on the CSS. This gives us a 50% speed-up in the parser,
|
|
// and a smaller speed-up in the code-gen.
|
|
//
|
|
//
|
|
// Token matching is done with the `$` function, which either takes
|
|
// a terminal string or regexp, or a non-terminal function to call.
|
|
// It also takes care of moving all the indices forwards.
|
|
//
|
|
|
|
var Parser = function Parser(context, imports, fileInfo) {
|
|
var parsers;
|
|
var parserInput = getParserInput();
|
|
|
|
function error(msg, type) {
|
|
throw new LessError({
|
|
index: parserInput.i,
|
|
filename: fileInfo.filename,
|
|
type: type || 'Syntax',
|
|
message: msg
|
|
}, imports);
|
|
}
|
|
|
|
function expect(arg, msg) {
|
|
// some older browsers return typeof 'function' for RegExp
|
|
var result = arg instanceof Function ? arg.call(parsers) : parserInput.$re(arg);
|
|
|
|
if (result) {
|
|
return result;
|
|
}
|
|
|
|
error(msg || (typeof arg === 'string' ? `expected '${arg}' got '${parserInput.currentChar()}'` : 'unexpected token'));
|
|
} // Specialization of expect()
|
|
|
|
|
|
function expectChar(arg, msg) {
|
|
if (parserInput.$char(arg)) {
|
|
return arg;
|
|
}
|
|
|
|
error(msg || `expected '${arg}' got '${parserInput.currentChar()}'`);
|
|
}
|
|
|
|
function getDebugInfo(index) {
|
|
var filename = fileInfo.filename;
|
|
return {
|
|
lineNumber: getLocation(index, parserInput.getInput()).line + 1,
|
|
fileName: filename
|
|
};
|
|
}
|
|
/**
|
|
* Used after initial parsing to create nodes on the fly
|
|
*
|
|
* @param {String} str - string to parse
|
|
* @param {Array} parseList - array of parsers to run input through e.g. ["value", "important"]
|
|
* @param {Number} currentIndex - start number to begin indexing
|
|
* @param {Object} fileInfo - fileInfo to attach to created nodes
|
|
*/
|
|
|
|
|
|
function parseNode(str, parseList, currentIndex, fileInfo, callback) {
|
|
var result;
|
|
var returnNodes = [];
|
|
var parser = parserInput;
|
|
|
|
try {
|
|
parser.start(str, false, function fail(msg, index) {
|
|
callback({
|
|
message: msg,
|
|
index: index + currentIndex
|
|
});
|
|
});
|
|
|
|
for (var x = 0, p, i; p = parseList[x]; x++) {
|
|
i = parser.i;
|
|
result = parsers[p]();
|
|
|
|
if (result) {
|
|
try {
|
|
result._index = i + currentIndex;
|
|
result._fileInfo = fileInfo;
|
|
} catch (e) {}
|
|
|
|
returnNodes.push(result);
|
|
} else {
|
|
returnNodes.push(null);
|
|
}
|
|
}
|
|
|
|
var endInfo = parser.end();
|
|
|
|
if (endInfo.isFinished) {
|
|
callback(null, returnNodes);
|
|
} else {
|
|
callback(true, null);
|
|
}
|
|
} catch (e) {
|
|
throw new LessError({
|
|
index: e.index + currentIndex,
|
|
message: e.message
|
|
}, imports, fileInfo.filename);
|
|
}
|
|
} //
|
|
// The Parser
|
|
//
|
|
|
|
|
|
return {
|
|
parserInput,
|
|
imports,
|
|
fileInfo,
|
|
parseNode,
|
|
//
|
|
// Parse an input string into an abstract syntax tree,
|
|
// @param str A string containing 'less' markup
|
|
// @param callback call `callback` when done.
|
|
// @param [additionalData] An optional map which can contains vars - a map (key, value) of variables to apply
|
|
//
|
|
parse: function parse(str, callback, additionalData) {
|
|
var root;
|
|
var error = null;
|
|
var globalVars;
|
|
var modifyVars;
|
|
var ignored;
|
|
var preText = '';
|
|
globalVars = additionalData && additionalData.globalVars ? `${Parser.serializeVars(additionalData.globalVars)}\n` : '';
|
|
modifyVars = additionalData && additionalData.modifyVars ? `\n${Parser.serializeVars(additionalData.modifyVars)}` : '';
|
|
|
|
if (context.pluginManager) {
|
|
var preProcessors = context.pluginManager.getPreProcessors();
|
|
|
|
for (var i = 0; i < preProcessors.length; i++) {
|
|
str = preProcessors[i].process(str, {
|
|
context,
|
|
imports,
|
|
fileInfo
|
|
});
|
|
}
|
|
}
|
|
|
|
if (globalVars || additionalData && additionalData.banner) {
|
|
preText = (additionalData && additionalData.banner ? additionalData.banner : '') + globalVars;
|
|
ignored = imports.contentsIgnoredChars;
|
|
ignored[fileInfo.filename] = ignored[fileInfo.filename] || 0;
|
|
ignored[fileInfo.filename] += preText.length;
|
|
}
|
|
|
|
str = str.replace(/\r\n?/g, '\n'); // Remove potential UTF Byte Order Mark
|
|
|
|
str = preText + str.replace(/^\uFEFF/, '') + modifyVars;
|
|
imports.contents[fileInfo.filename] = str; // Start with the primary rule.
|
|
// The whole syntax tree is held under a Ruleset node,
|
|
// with the `root` property set to true, so no `{}` are
|
|
// output. The callback is called when the input is parsed.
|
|
|
|
try {
|
|
parserInput.start(str, context.chunkInput, function fail(msg, index) {
|
|
throw new LessError({
|
|
index,
|
|
type: 'Parse',
|
|
message: msg,
|
|
filename: fileInfo.filename
|
|
}, imports);
|
|
});
|
|
tree.Node.prototype.parse = this;
|
|
root = new tree.Ruleset(null, this.parsers.primary());
|
|
tree.Node.prototype.rootNode = root;
|
|
root.root = true;
|
|
root.firstRoot = true;
|
|
root.functionRegistry = functionRegistry.inherit();
|
|
} catch (e) {
|
|
return callback(new LessError(e, imports, fileInfo.filename));
|
|
} // If `i` is smaller than the `input.length - 1`,
|
|
// it means the parser wasn't able to parse the whole
|
|
// string, so we've got a parsing error.
|
|
//
|
|
// We try to extract a \n delimited string,
|
|
// showing the line where the parse error occurred.
|
|
// We split it up into two parts (the part which parsed,
|
|
// and the part which didn't), so we can color them differently.
|
|
|
|
|
|
var endInfo = parserInput.end();
|
|
|
|
if (!endInfo.isFinished) {
|
|
var message = endInfo.furthestPossibleErrorMessage;
|
|
|
|
if (!message) {
|
|
message = 'Unrecognised input';
|
|
|
|
if (endInfo.furthestChar === '}') {
|
|
message += '. Possibly missing opening \'{\'';
|
|
} else if (endInfo.furthestChar === ')') {
|
|
message += '. Possibly missing opening \'(\'';
|
|
} else if (endInfo.furthestReachedEnd) {
|
|
message += '. Possibly missing something';
|
|
}
|
|
}
|
|
|
|
error = new LessError({
|
|
type: 'Parse',
|
|
message,
|
|
index: endInfo.furthest,
|
|
filename: fileInfo.filename
|
|
}, imports);
|
|
}
|
|
|
|
var finish = function finish(e) {
|
|
e = error || e || imports.error;
|
|
|
|
if (e) {
|
|
if (!(e instanceof LessError)) {
|
|
e = new LessError(e, imports, fileInfo.filename);
|
|
}
|
|
|
|
return callback(e);
|
|
} else {
|
|
return callback(null, root);
|
|
}
|
|
};
|
|
|
|
if (context.processImports !== false) {
|
|
new visitors.ImportVisitor(imports, finish).run(root);
|
|
} else {
|
|
return finish();
|
|
}
|
|
},
|
|
//
|
|
// Here in, the parsing rules/functions
|
|
//
|
|
// The basic structure of the syntax tree generated is as follows:
|
|
//
|
|
// Ruleset -> Declaration -> Value -> Expression -> Entity
|
|
//
|
|
// Here's some Less code:
|
|
//
|
|
// .class {
|
|
// color: #fff;
|
|
// border: 1px solid #000;
|
|
// width: @w + 4px;
|
|
// > .child {...}
|
|
// }
|
|
//
|
|
// And here's what the parse tree might look like:
|
|
//
|
|
// Ruleset (Selector '.class', [
|
|
// Declaration ("color", Value ([Expression [Color #fff]]))
|
|
// Declaration ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]]))
|
|
// Declaration ("width", Value ([Expression [Operation " + " [Variable "@w"][Dimension 4px]]]))
|
|
// Ruleset (Selector [Element '>', '.child'], [...])
|
|
// ])
|
|
//
|
|
// In general, most rules will try to parse a token with the `$re()` function, and if the return
|
|
// value is truly, will return a new node, of the relevant type. Sometimes, we need to check
|
|
// first, before parsing, that's when we use `peek()`.
|
|
//
|
|
parsers: parsers = {
|
|
//
|
|
// The `primary` rule is the *entry* and *exit* point of the parser.
|
|
// The rules here can appear at any level of the parse tree.
|
|
//
|
|
// The recursive nature of the grammar is an interplay between the `block`
|
|
// rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,
|
|
// as represented by this simplified grammar:
|
|
//
|
|
// primary → (ruleset | declaration)+
|
|
// ruleset → selector+ block
|
|
// block → '{' primary '}'
|
|
//
|
|
// Only at one point is the primary rule not called from the
|
|
// block rule: at the root level.
|
|
//
|
|
primary: function primary() {
|
|
var mixin = this.mixin;
|
|
var root = [];
|
|
var node;
|
|
|
|
while (true) {
|
|
while (true) {
|
|
node = this.comment();
|
|
|
|
if (!node) {
|
|
break;
|
|
}
|
|
|
|
root.push(node);
|
|
} // always process comments before deciding if finished
|
|
|
|
|
|
if (parserInput.finished) {
|
|
break;
|
|
}
|
|
|
|
if (parserInput.peek('}')) {
|
|
break;
|
|
}
|
|
|
|
node = this.extendRule();
|
|
|
|
if (node) {
|
|
root = root.concat(node);
|
|
continue;
|
|
}
|
|
|
|
node = mixin.definition() || this.declaration() || this.ruleset() || mixin.call(false, false) || this.variableCall() || this.entities.call() || this.atrule();
|
|
|
|
if (node) {
|
|
root.push(node);
|
|
} else {
|
|
var foundSemiColon = false;
|
|
|
|
while (parserInput.$char(';')) {
|
|
foundSemiColon = true;
|
|
}
|
|
|
|
if (!foundSemiColon) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return root;
|
|
},
|
|
// comments are collected by the main parsing mechanism and then assigned to nodes
|
|
// where the current structure allows it
|
|
comment: function comment() {
|
|
if (parserInput.commentStore.length) {
|
|
var comment = parserInput.commentStore.shift();
|
|
return new tree.Comment(comment.text, comment.isLineComment, comment.index, fileInfo);
|
|
}
|
|
},
|
|
//
|
|
// Entities are tokens which can be found inside an Expression
|
|
//
|
|
entities: {
|
|
mixinLookup: function mixinLookup() {
|
|
return parsers.mixin.call(true, true);
|
|
},
|
|
//
|
|
// A string, which supports escaping " and '
|
|
//
|
|
// "milky way" 'he\'s the one!'
|
|
//
|
|
quoted: function quoted(forceEscaped) {
|
|
var str;
|
|
var index = parserInput.i;
|
|
var isEscaped = false;
|
|
parserInput.save();
|
|
|
|
if (parserInput.$char('~')) {
|
|
isEscaped = true;
|
|
} else if (forceEscaped) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
str = parserInput.$quoted();
|
|
|
|
if (!str) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
parserInput.forget();
|
|
return new tree.Quoted(str.charAt(0), str.substr(1, str.length - 2), isEscaped, index, fileInfo);
|
|
},
|
|
//
|
|
// A catch-all word, such as:
|
|
//
|
|
// black border-collapse
|
|
//
|
|
keyword: function keyword() {
|
|
var k = parserInput.$char('%') || parserInput.$re(/^\[?(?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+\]?/);
|
|
|
|
if (k) {
|
|
return tree.Color.fromKeyword(k) || new tree.Keyword(k);
|
|
}
|
|
},
|
|
//
|
|
// A function call
|
|
//
|
|
// rgb(255, 0, 255)
|
|
//
|
|
// The arguments are parsed with the `entities.arguments` parser.
|
|
//
|
|
call: function call() {
|
|
var name;
|
|
var args;
|
|
var func;
|
|
var index = parserInput.i; // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
|
|
|
|
if (parserInput.peek(/^url\(/i)) {
|
|
return;
|
|
}
|
|
|
|
parserInput.save();
|
|
name = parserInput.$re(/^([\w-]+|%|progid:[\w\.]+)\(/);
|
|
|
|
if (!name) {
|
|
parserInput.forget();
|
|
return;
|
|
}
|
|
|
|
name = name[1];
|
|
func = this.customFuncCall(name);
|
|
|
|
if (func) {
|
|
args = func.parse();
|
|
|
|
if (args && func.stop) {
|
|
parserInput.forget();
|
|
return args;
|
|
}
|
|
}
|
|
|
|
args = this.arguments(args);
|
|
|
|
if (!parserInput.$char(')')) {
|
|
parserInput.restore('Could not parse call arguments or missing \')\'');
|
|
return;
|
|
}
|
|
|
|
parserInput.forget();
|
|
return new tree.Call(name, args, index, fileInfo);
|
|
},
|
|
//
|
|
// Parsing rules for functions with non-standard args, e.g.:
|
|
//
|
|
// boolean(not(2 > 1))
|
|
//
|
|
// This is a quick prototype, to be modified/improved when
|
|
// more custom-parsed funcs come (e.g. `selector(...)`)
|
|
//
|
|
customFuncCall: function customFuncCall(name) {
|
|
/* Ideally the table is to be moved out of here for faster perf.,
|
|
but it's quite tricky since it relies on all these `parsers`
|
|
and `expect` available only here */
|
|
return {
|
|
alpha: f(parsers.ieAlpha, true),
|
|
boolean: f(condition),
|
|
'if': f(condition)
|
|
}[name.toLowerCase()];
|
|
|
|
function f(parse, stop) {
|
|
return {
|
|
parse,
|
|
// parsing function
|
|
stop // when true - stop after parse() and return its result,
|
|
// otherwise continue for plain args
|
|
|
|
};
|
|
}
|
|
|
|
function condition() {
|
|
return [expect(parsers.condition, 'expected condition')];
|
|
}
|
|
},
|
|
arguments: function _arguments(prevArgs) {
|
|
var argsComma = prevArgs || [];
|
|
var argsSemiColon = [];
|
|
var isSemiColonSeparated;
|
|
var value;
|
|
parserInput.save();
|
|
|
|
while (true) {
|
|
if (prevArgs) {
|
|
prevArgs = false;
|
|
} else {
|
|
value = parsers.detachedRuleset() || this.assignment() || parsers.expression();
|
|
|
|
if (!value) {
|
|
break;
|
|
}
|
|
|
|
if (value.value && value.value.length == 1) {
|
|
value = value.value[0];
|
|
}
|
|
|
|
argsComma.push(value);
|
|
}
|
|
|
|
if (parserInput.$char(',')) {
|
|
continue;
|
|
}
|
|
|
|
if (parserInput.$char(';') || isSemiColonSeparated) {
|
|
isSemiColonSeparated = true;
|
|
value = argsComma.length < 1 ? argsComma[0] : new tree.Value(argsComma);
|
|
argsSemiColon.push(value);
|
|
argsComma = [];
|
|
}
|
|
}
|
|
|
|
parserInput.forget();
|
|
return isSemiColonSeparated ? argsSemiColon : argsComma;
|
|
},
|
|
literal: function literal() {
|
|
return this.dimension() || this.color() || this.quoted() || this.unicodeDescriptor();
|
|
},
|
|
// Assignments are argument entities for calls.
|
|
// They are present in ie filter properties as shown below.
|
|
//
|
|
// filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* )
|
|
//
|
|
assignment: function assignment() {
|
|
var key;
|
|
var value;
|
|
parserInput.save();
|
|
key = parserInput.$re(/^\w+(?=\s?=)/i);
|
|
|
|
if (!key) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (!parserInput.$char('=')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
value = parsers.entity();
|
|
|
|
if (value) {
|
|
parserInput.forget();
|
|
return new tree.Assignment(key, value);
|
|
} else {
|
|
parserInput.restore();
|
|
}
|
|
},
|
|
//
|
|
// Parse url() tokens
|
|
//
|
|
// We use a specific rule for urls, because they don't really behave like
|
|
// standard function calls. The difference is that the argument doesn't have
|
|
// to be enclosed within a string, so it can't be parsed as an Expression.
|
|
//
|
|
url: function url() {
|
|
var value;
|
|
var index = parserInput.i;
|
|
parserInput.autoCommentAbsorb = false;
|
|
|
|
if (!parserInput.$str('url(')) {
|
|
parserInput.autoCommentAbsorb = true;
|
|
return;
|
|
}
|
|
|
|
value = this.quoted() || this.variable() || this.property() || parserInput.$re(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || '';
|
|
parserInput.autoCommentAbsorb = true;
|
|
expectChar(')');
|
|
return new tree.URL(value.value != null || value instanceof tree.Variable || value instanceof tree.Property ? value : new tree.Anonymous(value, index), index, fileInfo);
|
|
},
|
|
//
|
|
// A Variable entity, such as `@fink`, in
|
|
//
|
|
// width: @fink + 2px
|
|
//
|
|
// We use a different parser for variable definitions,
|
|
// see `parsers.variable`.
|
|
//
|
|
variable: function variable() {
|
|
var ch;
|
|
var name;
|
|
var index = parserInput.i;
|
|
parserInput.save();
|
|
|
|
if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^@@?[\w-]+/))) {
|
|
ch = parserInput.currentChar();
|
|
|
|
if (ch === '(' || ch === '[' && !parserInput.prevChar().match(/^\s/)) {
|
|
// this may be a VariableCall lookup
|
|
var result = parsers.variableCall(name);
|
|
|
|
if (result) {
|
|
parserInput.forget();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
parserInput.forget();
|
|
return new tree.Variable(name, index, fileInfo);
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
// A variable entity using the protective {} e.g. @{var}
|
|
variableCurly: function variableCurly() {
|
|
var curly;
|
|
var index = parserInput.i;
|
|
|
|
if (parserInput.currentChar() === '@' && (curly = parserInput.$re(/^@\{([\w-]+)\}/))) {
|
|
return new tree.Variable(`@${curly[1]}`, index, fileInfo);
|
|
}
|
|
},
|
|
//
|
|
// A Property accessor, such as `$color`, in
|
|
//
|
|
// background-color: $color
|
|
//
|
|
property: function property() {
|
|
var name;
|
|
var index = parserInput.i;
|
|
|
|
if (parserInput.currentChar() === '$' && (name = parserInput.$re(/^\$[\w-]+/))) {
|
|
return new tree.Property(name, index, fileInfo);
|
|
}
|
|
},
|
|
// A property entity useing the protective {} e.g. ${prop}
|
|
propertyCurly: function propertyCurly() {
|
|
var curly;
|
|
var index = parserInput.i;
|
|
|
|
if (parserInput.currentChar() === '$' && (curly = parserInput.$re(/^\$\{([\w-]+)\}/))) {
|
|
return new tree.Property(`$${curly[1]}`, index, fileInfo);
|
|
}
|
|
},
|
|
//
|
|
// A Hexadecimal color
|
|
//
|
|
// #4F3C2F
|
|
//
|
|
// `rgb` and `hsl` colors are parsed through the `entities.call` parser.
|
|
//
|
|
color: function color() {
|
|
var rgb;
|
|
parserInput.save();
|
|
|
|
if (parserInput.currentChar() === '#' && (rgb = parserInput.$re(/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})([\w.#\[])?/))) {
|
|
if (!rgb[2]) {
|
|
parserInput.forget();
|
|
return new tree.Color(rgb[1], undefined, rgb[0]);
|
|
}
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
colorKeyword: function colorKeyword() {
|
|
parserInput.save();
|
|
var autoCommentAbsorb = parserInput.autoCommentAbsorb;
|
|
parserInput.autoCommentAbsorb = false;
|
|
var k = parserInput.$re(/^[_A-Za-z-][_A-Za-z0-9-]+/);
|
|
parserInput.autoCommentAbsorb = autoCommentAbsorb;
|
|
|
|
if (!k) {
|
|
parserInput.forget();
|
|
return;
|
|
}
|
|
|
|
parserInput.restore();
|
|
var color = tree.Color.fromKeyword(k);
|
|
|
|
if (color) {
|
|
parserInput.$str(k);
|
|
return color;
|
|
}
|
|
},
|
|
//
|
|
// A Dimension, that is, a number and a unit
|
|
//
|
|
// 0.5em 95%
|
|
//
|
|
dimension: function dimension() {
|
|
if (parserInput.peekNotNumeric()) {
|
|
return;
|
|
}
|
|
|
|
var value = parserInput.$re(/^([+-]?\d*\.?\d+)(%|[a-z_]+)?/i);
|
|
|
|
if (value) {
|
|
return new tree.Dimension(value[1], value[2]);
|
|
}
|
|
},
|
|
//
|
|
// A unicode descriptor, as is used in unicode-range
|
|
//
|
|
// U+0?? or U+00A1-00A9
|
|
//
|
|
unicodeDescriptor: function unicodeDescriptor() {
|
|
var ud;
|
|
ud = parserInput.$re(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/);
|
|
|
|
if (ud) {
|
|
return new tree.UnicodeDescriptor(ud[0]);
|
|
}
|
|
},
|
|
//
|
|
// JavaScript code to be evaluated
|
|
//
|
|
// `window.location.href`
|
|
//
|
|
javascript: function javascript() {
|
|
var js;
|
|
var index = parserInput.i;
|
|
parserInput.save();
|
|
var escape = parserInput.$char('~');
|
|
var jsQuote = parserInput.$char('`');
|
|
|
|
if (!jsQuote) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
js = parserInput.$re(/^[^`]*`/);
|
|
|
|
if (js) {
|
|
parserInput.forget();
|
|
return new tree.JavaScript(js.substr(0, js.length - 1), Boolean(escape), index, fileInfo);
|
|
}
|
|
|
|
parserInput.restore('invalid javascript definition');
|
|
}
|
|
},
|
|
//
|
|
// The variable part of a variable definition. Used in the `rule` parser
|
|
//
|
|
// @fink:
|
|
//
|
|
variable: function variable() {
|
|
var name;
|
|
|
|
if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) {
|
|
return name[1];
|
|
}
|
|
},
|
|
//
|
|
// Call a variable value to retrieve a detached ruleset
|
|
// or a value from a detached ruleset's rules.
|
|
//
|
|
// @fink();
|
|
// @fink;
|
|
// color: @fink[@color];
|
|
//
|
|
variableCall: function variableCall(parsedName) {
|
|
var lookups;
|
|
var important;
|
|
var i = parserInput.i;
|
|
var inValue = !!parsedName;
|
|
var name = parsedName;
|
|
parserInput.save();
|
|
|
|
if (name || parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)(\(\s*\))?/))) {
|
|
lookups = this.mixin.ruleLookups();
|
|
|
|
if (!lookups && (inValue && parserInput.$str('()') !== '()' || name[2] !== '()')) {
|
|
parserInput.restore('Missing \'[...]\' lookup in variable call');
|
|
return;
|
|
}
|
|
|
|
if (!inValue) {
|
|
name = name[1];
|
|
}
|
|
|
|
if (lookups && parsers.important()) {
|
|
important = true;
|
|
}
|
|
|
|
var call = new tree.VariableCall(name, i, fileInfo);
|
|
|
|
if (!inValue && parsers.end()) {
|
|
parserInput.forget();
|
|
return call;
|
|
} else {
|
|
parserInput.forget();
|
|
return new tree.NamespaceValue(call, lookups, important, i, fileInfo);
|
|
}
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
//
|
|
// extend syntax - used to extend selectors
|
|
//
|
|
extend: function extend(isRule) {
|
|
var elements;
|
|
var e;
|
|
var index = parserInput.i;
|
|
var option;
|
|
var extendList;
|
|
var extend;
|
|
|
|
if (!parserInput.$str(isRule ? '&:extend(' : ':extend(')) {
|
|
return;
|
|
}
|
|
|
|
do {
|
|
option = null;
|
|
elements = null;
|
|
|
|
while (!(option = parserInput.$re(/^(all)(?=\s*(\)|,))/))) {
|
|
e = this.element();
|
|
|
|
if (!e) {
|
|
break;
|
|
}
|
|
|
|
if (elements) {
|
|
elements.push(e);
|
|
} else {
|
|
elements = [e];
|
|
}
|
|
}
|
|
|
|
option = option && option[1];
|
|
|
|
if (!elements) {
|
|
error('Missing target selector for :extend().');
|
|
}
|
|
|
|
extend = new tree.Extend(new tree.Selector(elements), option, index, fileInfo);
|
|
|
|
if (extendList) {
|
|
extendList.push(extend);
|
|
} else {
|
|
extendList = [extend];
|
|
}
|
|
} while (parserInput.$char(','));
|
|
|
|
expect(/^\)/);
|
|
|
|
if (isRule) {
|
|
expect(/^;/);
|
|
}
|
|
|
|
return extendList;
|
|
},
|
|
//
|
|
// extendRule - used in a rule to extend all the parent selectors
|
|
//
|
|
extendRule: function extendRule() {
|
|
return this.extend(true);
|
|
},
|
|
//
|
|
// Mixins
|
|
//
|
|
mixin: {
|
|
//
|
|
// A Mixin call, with an optional argument list
|
|
//
|
|
// #mixins > .square(#fff);
|
|
// #mixins.square(#fff);
|
|
// .rounded(4px, black);
|
|
// .button;
|
|
//
|
|
// We can lookup / return a value using the lookup syntax:
|
|
//
|
|
// color: #mixin.square(#fff)[@color];
|
|
//
|
|
// The `while` loop is there because mixins can be
|
|
// namespaced, but we only support the child and descendant
|
|
// selector for now.
|
|
//
|
|
call: function call(inValue, getLookup) {
|
|
var s = parserInput.currentChar();
|
|
var important = false;
|
|
var lookups;
|
|
var index = parserInput.i;
|
|
var elements;
|
|
var args;
|
|
var hasParens;
|
|
|
|
if (s !== '.' && s !== '#') {
|
|
return;
|
|
}
|
|
|
|
parserInput.save(); // stop us absorbing part of an invalid selector
|
|
|
|
elements = this.elements();
|
|
|
|
if (elements) {
|
|
if (parserInput.$char('(')) {
|
|
args = this.args(true).args;
|
|
expectChar(')');
|
|
hasParens = true;
|
|
}
|
|
|
|
if (getLookup !== false) {
|
|
lookups = this.ruleLookups();
|
|
}
|
|
|
|
if (getLookup === true && !lookups) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (inValue && !lookups && !hasParens) {
|
|
// This isn't a valid in-value mixin call
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (!inValue && parsers.important()) {
|
|
important = true;
|
|
}
|
|
|
|
if (inValue || parsers.end()) {
|
|
parserInput.forget();
|
|
var mixin = new tree.mixin.Call(elements, args, index, fileInfo, !lookups && important);
|
|
|
|
if (lookups) {
|
|
return new tree.NamespaceValue(mixin, lookups, important);
|
|
} else {
|
|
return mixin;
|
|
}
|
|
}
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
|
|
/**
|
|
* Matching elements for mixins
|
|
* (Start with . or # and can have > )
|
|
*/
|
|
elements: function elements() {
|
|
var elements;
|
|
var e;
|
|
var c;
|
|
var elem;
|
|
var elemIndex;
|
|
var re = /^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/;
|
|
|
|
while (true) {
|
|
elemIndex = parserInput.i;
|
|
e = parserInput.$re(re);
|
|
|
|
if (!e) {
|
|
break;
|
|
}
|
|
|
|
elem = new tree.Element(c, e, false, elemIndex, fileInfo);
|
|
|
|
if (elements) {
|
|
elements.push(elem);
|
|
} else {
|
|
elements = [elem];
|
|
}
|
|
|
|
c = parserInput.$char('>');
|
|
}
|
|
|
|
return elements;
|
|
},
|
|
args: function args(isCall) {
|
|
var entities = parsers.entities;
|
|
var returner = {
|
|
args: null,
|
|
variadic: false
|
|
};
|
|
var expressions = [];
|
|
var argsSemiColon = [];
|
|
var argsComma = [];
|
|
var isSemiColonSeparated;
|
|
var expressionContainsNamed;
|
|
var name;
|
|
var nameLoop;
|
|
var value;
|
|
var arg;
|
|
var expand;
|
|
var hasSep = true;
|
|
parserInput.save();
|
|
|
|
while (true) {
|
|
if (isCall) {
|
|
arg = parsers.detachedRuleset() || parsers.expression();
|
|
} else {
|
|
parserInput.commentStore.length = 0;
|
|
|
|
if (parserInput.$str('...')) {
|
|
returner.variadic = true;
|
|
|
|
if (parserInput.$char(';') && !isSemiColonSeparated) {
|
|
isSemiColonSeparated = true;
|
|
}
|
|
|
|
(isSemiColonSeparated ? argsSemiColon : argsComma).push({
|
|
variadic: true
|
|
});
|
|
break;
|
|
}
|
|
|
|
arg = entities.variable() || entities.property() || entities.literal() || entities.keyword() || this.call(true);
|
|
}
|
|
|
|
if (!arg || !hasSep) {
|
|
break;
|
|
}
|
|
|
|
nameLoop = null;
|
|
|
|
if (arg.throwAwayComments) {
|
|
arg.throwAwayComments();
|
|
}
|
|
|
|
value = arg;
|
|
var val = null;
|
|
|
|
if (isCall) {
|
|
// Variable
|
|
if (arg.value && arg.value.length == 1) {
|
|
val = arg.value[0];
|
|
}
|
|
} else {
|
|
val = arg;
|
|
}
|
|
|
|
if (val && (val instanceof tree.Variable || val instanceof tree.Property)) {
|
|
if (parserInput.$char(':')) {
|
|
if (expressions.length > 0) {
|
|
if (isSemiColonSeparated) {
|
|
error('Cannot mix ; and , as delimiter types');
|
|
}
|
|
|
|
expressionContainsNamed = true;
|
|
}
|
|
|
|
value = parsers.detachedRuleset() || parsers.expression();
|
|
|
|
if (!value) {
|
|
if (isCall) {
|
|
error('could not understand value for named argument');
|
|
} else {
|
|
parserInput.restore();
|
|
returner.args = [];
|
|
return returner;
|
|
}
|
|
}
|
|
|
|
nameLoop = name = val.name;
|
|
} else if (parserInput.$str('...')) {
|
|
if (!isCall) {
|
|
returner.variadic = true;
|
|
|
|
if (parserInput.$char(';') && !isSemiColonSeparated) {
|
|
isSemiColonSeparated = true;
|
|
}
|
|
|
|
(isSemiColonSeparated ? argsSemiColon : argsComma).push({
|
|
name: arg.name,
|
|
variadic: true
|
|
});
|
|
break;
|
|
} else {
|
|
expand = true;
|
|
}
|
|
} else if (!isCall) {
|
|
name = nameLoop = val.name;
|
|
value = null;
|
|
}
|
|
}
|
|
|
|
if (value) {
|
|
expressions.push(value);
|
|
}
|
|
|
|
argsComma.push({
|
|
name: nameLoop,
|
|
value,
|
|
expand
|
|
});
|
|
|
|
if (parserInput.$char(',')) {
|
|
hasSep = true;
|
|
continue;
|
|
}
|
|
|
|
hasSep = parserInput.$char(';') === ';';
|
|
|
|
if (hasSep || isSemiColonSeparated) {
|
|
if (expressionContainsNamed) {
|
|
error('Cannot mix ; and , as delimiter types');
|
|
}
|
|
|
|
isSemiColonSeparated = true;
|
|
|
|
if (expressions.length > 1) {
|
|
value = new tree.Value(expressions);
|
|
}
|
|
|
|
argsSemiColon.push({
|
|
name,
|
|
value,
|
|
expand
|
|
});
|
|
name = null;
|
|
expressions = [];
|
|
expressionContainsNamed = false;
|
|
}
|
|
}
|
|
|
|
parserInput.forget();
|
|
returner.args = isSemiColonSeparated ? argsSemiColon : argsComma;
|
|
return returner;
|
|
},
|
|
//
|
|
// A Mixin definition, with a list of parameters
|
|
//
|
|
// .rounded (@radius: 2px, @color) {
|
|
// ...
|
|
// }
|
|
//
|
|
// Until we have a finer grained state-machine, we have to
|
|
// do a look-ahead, to make sure we don't have a mixin call.
|
|
// See the `rule` function for more information.
|
|
//
|
|
// We start by matching `.rounded (`, and then proceed on to
|
|
// the argument list, which has optional default values.
|
|
// We store the parameters in `params`, with a `value` key,
|
|
// if there is a value, such as in the case of `@radius`.
|
|
//
|
|
// Once we've got our params list, and a closing `)`, we parse
|
|
// the `{...}` block.
|
|
//
|
|
definition: function definition() {
|
|
var name;
|
|
var params = [];
|
|
var match;
|
|
var ruleset;
|
|
var cond;
|
|
var variadic = false;
|
|
|
|
if (parserInput.currentChar() !== '.' && parserInput.currentChar() !== '#' || parserInput.peek(/^[^{]*\}/)) {
|
|
return;
|
|
}
|
|
|
|
parserInput.save();
|
|
match = parserInput.$re(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/);
|
|
|
|
if (match) {
|
|
name = match[1];
|
|
var argInfo = this.args(false);
|
|
params = argInfo.args;
|
|
variadic = argInfo.variadic; // .mixincall("@{a}");
|
|
// looks a bit like a mixin definition..
|
|
// also
|
|
// .mixincall(@a: {rule: set;});
|
|
// so we have to be nice and restore
|
|
|
|
if (!parserInput.$char(')')) {
|
|
parserInput.restore('Missing closing \')\'');
|
|
return;
|
|
}
|
|
|
|
parserInput.commentStore.length = 0;
|
|
|
|
if (parserInput.$str('when')) {
|
|
// Guard
|
|
cond = expect(parsers.conditions, 'expected condition');
|
|
}
|
|
|
|
ruleset = parsers.block();
|
|
|
|
if (ruleset) {
|
|
parserInput.forget();
|
|
return new tree.mixin.Definition(name, params, ruleset, cond, variadic);
|
|
} else {
|
|
parserInput.restore();
|
|
}
|
|
} else {
|
|
parserInput.forget();
|
|
}
|
|
},
|
|
ruleLookups: function ruleLookups() {
|
|
var rule;
|
|
var lookups = [];
|
|
|
|
if (parserInput.currentChar() !== '[') {
|
|
return;
|
|
}
|
|
|
|
while (true) {
|
|
parserInput.save();
|
|
rule = this.lookupValue();
|
|
|
|
if (!rule && rule !== '') {
|
|
parserInput.restore();
|
|
break;
|
|
}
|
|
|
|
lookups.push(rule);
|
|
parserInput.forget();
|
|
}
|
|
|
|
if (lookups.length > 0) {
|
|
return lookups;
|
|
}
|
|
},
|
|
lookupValue: function lookupValue() {
|
|
parserInput.save();
|
|
|
|
if (!parserInput.$char('[')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
var name = parserInput.$re(/^(?:[@$]{0,2})[_a-zA-Z0-9-]*/);
|
|
|
|
if (!parserInput.$char(']')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (name || name === '') {
|
|
parserInput.forget();
|
|
return name;
|
|
}
|
|
|
|
parserInput.restore();
|
|
}
|
|
},
|
|
//
|
|
// Entities are the smallest recognized token,
|
|
// and can be found inside a rule's value.
|
|
//
|
|
entity: function entity() {
|
|
var entities = this.entities;
|
|
return this.comment() || entities.literal() || entities.variable() || entities.url() || entities.property() || entities.call() || entities.keyword() || this.mixin.call(true) || entities.javascript();
|
|
},
|
|
//
|
|
// A Declaration terminator. Note that we use `peek()` to check for '}',
|
|
// because the `block` rule will be expecting it, but we still need to make sure
|
|
// it's there, if ';' was omitted.
|
|
//
|
|
end: function end() {
|
|
return parserInput.$char(';') || parserInput.peek('}');
|
|
},
|
|
//
|
|
// IE's alpha function
|
|
//
|
|
// alpha(opacity=88)
|
|
//
|
|
ieAlpha: function ieAlpha() {
|
|
var value; // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
|
|
|
|
if (!parserInput.$re(/^opacity=/i)) {
|
|
return;
|
|
}
|
|
|
|
value = parserInput.$re(/^\d+/);
|
|
|
|
if (!value) {
|
|
value = expect(parsers.entities.variable, 'Could not parse alpha');
|
|
value = `@{${value.name.slice(1)}}`;
|
|
}
|
|
|
|
expectChar(')');
|
|
return new tree.Quoted('', `alpha(opacity=${value})`);
|
|
},
|
|
//
|
|
// A Selector Element
|
|
//
|
|
// div
|
|
// + h1
|
|
// #socks
|
|
// input[type="text"]
|
|
//
|
|
// Elements are the building blocks for Selectors,
|
|
// they are made out of a `Combinator` (see combinator rule),
|
|
// and an element name, such as a tag a class, or `*`.
|
|
//
|
|
element: function element() {
|
|
var e;
|
|
var c;
|
|
var v;
|
|
var index = parserInput.i;
|
|
c = this.combinator();
|
|
e = parserInput.$re(/^(?:\d+\.\d+|\d+)%/) || parserInput.$re(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) || parserInput.$char('*') || parserInput.$char('&') || this.attribute() || parserInput.$re(/^\([^&()@]+\)/) || parserInput.$re(/^[\.#:](?=@)/) || this.entities.variableCurly();
|
|
|
|
if (!e) {
|
|
parserInput.save();
|
|
|
|
if (parserInput.$char('(')) {
|
|
if ((v = this.selector(false)) && parserInput.$char(')')) {
|
|
e = new tree.Paren(v);
|
|
parserInput.forget();
|
|
} else {
|
|
parserInput.restore('Missing closing \')\'');
|
|
}
|
|
} else {
|
|
parserInput.forget();
|
|
}
|
|
}
|
|
|
|
if (e) {
|
|
return new tree.Element(c, e, e instanceof tree.Variable, index, fileInfo);
|
|
}
|
|
},
|
|
//
|
|
// Combinators combine elements together, in a Selector.
|
|
//
|
|
// Because our parser isn't white-space sensitive, special care
|
|
// has to be taken, when parsing the descendant combinator, ` `,
|
|
// as it's an empty space. We have to check the previous character
|
|
// in the input, to see if it's a ` ` character. More info on how
|
|
// we deal with this in *combinator.js*.
|
|
//
|
|
combinator: function combinator() {
|
|
var c = parserInput.currentChar();
|
|
|
|
if (c === '/') {
|
|
parserInput.save();
|
|
var slashedCombinator = parserInput.$re(/^\/[a-z]+\//i);
|
|
|
|
if (slashedCombinator) {
|
|
parserInput.forget();
|
|
return new tree.Combinator(slashedCombinator);
|
|
}
|
|
|
|
parserInput.restore();
|
|
}
|
|
|
|
if (c === '>' || c === '+' || c === '~' || c === '|' || c === '^') {
|
|
parserInput.i++;
|
|
|
|
if (c === '^' && parserInput.currentChar() === '^') {
|
|
c = '^^';
|
|
parserInput.i++;
|
|
}
|
|
|
|
while (parserInput.isWhitespace()) {
|
|
parserInput.i++;
|
|
}
|
|
|
|
return new tree.Combinator(c);
|
|
} else if (parserInput.isWhitespace(-1)) {
|
|
return new tree.Combinator(' ');
|
|
} else {
|
|
return new tree.Combinator(null);
|
|
}
|
|
},
|
|
//
|
|
// A CSS Selector
|
|
// with less extensions e.g. the ability to extend and guard
|
|
//
|
|
// .class > div + h1
|
|
// li a:hover
|
|
//
|
|
// Selectors are made out of one or more Elements, see above.
|
|
//
|
|
selector: function selector(isLess) {
|
|
var index = parserInput.i;
|
|
var elements;
|
|
var extendList;
|
|
var c;
|
|
var e;
|
|
var allExtends;
|
|
var when;
|
|
var condition;
|
|
isLess = isLess !== false;
|
|
|
|
while (isLess && (extendList = this.extend()) || isLess && (when = parserInput.$str('when')) || (e = this.element())) {
|
|
if (when) {
|
|
condition = expect(this.conditions, 'expected condition');
|
|
} else if (condition) {
|
|
error('CSS guard can only be used at the end of selector');
|
|
} else if (extendList) {
|
|
if (allExtends) {
|
|
allExtends = allExtends.concat(extendList);
|
|
} else {
|
|
allExtends = extendList;
|
|
}
|
|
} else {
|
|
if (allExtends) {
|
|
error('Extend can only be used at the end of selector');
|
|
}
|
|
|
|
c = parserInput.currentChar();
|
|
|
|
if (elements) {
|
|
elements.push(e);
|
|
} else {
|
|
elements = [e];
|
|
}
|
|
|
|
e = null;
|
|
}
|
|
|
|
if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (elements) {
|
|
return new tree.Selector(elements, allExtends, condition, index, fileInfo);
|
|
}
|
|
|
|
if (allExtends) {
|
|
error('Extend must be used to extend a selector, it cannot be used on its own');
|
|
}
|
|
},
|
|
selectors: function selectors() {
|
|
var s;
|
|
var selectors;
|
|
|
|
while (true) {
|
|
s = this.selector();
|
|
|
|
if (!s) {
|
|
break;
|
|
}
|
|
|
|
if (selectors) {
|
|
selectors.push(s);
|
|
} else {
|
|
selectors = [s];
|
|
}
|
|
|
|
parserInput.commentStore.length = 0;
|
|
|
|
if (s.condition && selectors.length > 1) {
|
|
error("Guards are only currently allowed on a single selector.");
|
|
}
|
|
|
|
if (!parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
|
|
if (s.condition) {
|
|
error("Guards are only currently allowed on a single selector.");
|
|
}
|
|
|
|
parserInput.commentStore.length = 0;
|
|
}
|
|
|
|
return selectors;
|
|
},
|
|
attribute: function attribute() {
|
|
if (!parserInput.$char('[')) {
|
|
return;
|
|
}
|
|
|
|
var entities = this.entities;
|
|
var key;
|
|
var val;
|
|
var op;
|
|
|
|
if (!(key = entities.variableCurly())) {
|
|
key = expect(/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/);
|
|
}
|
|
|
|
op = parserInput.$re(/^[|~*$^]?=/);
|
|
|
|
if (op) {
|
|
val = entities.quoted() || parserInput.$re(/^[0-9]+%/) || parserInput.$re(/^[\w-]+/) || entities.variableCurly();
|
|
}
|
|
|
|
expectChar(']');
|
|
return new tree.Attribute(key, op, val);
|
|
},
|
|
//
|
|
// The `block` rule is used by `ruleset` and `mixin.definition`.
|
|
// It's a wrapper around the `primary` rule, with added `{}`.
|
|
//
|
|
block: function block() {
|
|
var content;
|
|
|
|
if (parserInput.$char('{') && (content = this.primary()) && parserInput.$char('}')) {
|
|
return content;
|
|
}
|
|
},
|
|
blockRuleset: function blockRuleset() {
|
|
var block = this.block();
|
|
|
|
if (block) {
|
|
block = new tree.Ruleset(null, block);
|
|
}
|
|
|
|
return block;
|
|
},
|
|
detachedRuleset: function detachedRuleset() {
|
|
var argInfo;
|
|
var params;
|
|
var variadic;
|
|
parserInput.save();
|
|
|
|
if (parserInput.$re(/^[.#]\(/)) {
|
|
/**
|
|
* DR args currently only implemented for each() function, and not
|
|
* yet settable as `@dr: #(@arg) {}`
|
|
* This should be done when DRs are merged with mixins.
|
|
* See: https://github.com/less/less-meta/issues/16
|
|
*/
|
|
argInfo = this.mixin.args(false);
|
|
params = argInfo.args;
|
|
variadic = argInfo.variadic;
|
|
|
|
if (!parserInput.$char(')')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
}
|
|
|
|
var blockRuleset = this.blockRuleset();
|
|
|
|
if (blockRuleset) {
|
|
parserInput.forget();
|
|
|
|
if (params) {
|
|
return new tree.mixin.Definition(null, params, blockRuleset, null, variadic);
|
|
}
|
|
|
|
return new tree.DetachedRuleset(blockRuleset);
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
//
|
|
// div, .class, body > p {...}
|
|
//
|
|
ruleset: function ruleset() {
|
|
var selectors;
|
|
var rules;
|
|
var debugInfo;
|
|
parserInput.save();
|
|
|
|
if (context.dumpLineNumbers) {
|
|
debugInfo = getDebugInfo(parserInput.i);
|
|
}
|
|
|
|
selectors = this.selectors();
|
|
|
|
if (selectors && (rules = this.block())) {
|
|
parserInput.forget();
|
|
var ruleset = new tree.Ruleset(selectors, rules, context.strictImports);
|
|
|
|
if (context.dumpLineNumbers) {
|
|
ruleset.debugInfo = debugInfo;
|
|
}
|
|
|
|
return ruleset;
|
|
} else {
|
|
parserInput.restore();
|
|
}
|
|
},
|
|
declaration: function declaration() {
|
|
var name;
|
|
var value;
|
|
var index = parserInput.i;
|
|
var hasDR;
|
|
var c = parserInput.currentChar();
|
|
var important;
|
|
var merge;
|
|
var isVariable;
|
|
|
|
if (c === '.' || c === '#' || c === '&' || c === ':') {
|
|
return;
|
|
}
|
|
|
|
parserInput.save();
|
|
name = this.variable() || this.ruleProperty();
|
|
|
|
if (name) {
|
|
isVariable = typeof name === 'string';
|
|
|
|
if (isVariable) {
|
|
value = this.detachedRuleset();
|
|
|
|
if (value) {
|
|
hasDR = true;
|
|
}
|
|
}
|
|
|
|
parserInput.commentStore.length = 0;
|
|
|
|
if (!value) {
|
|
// a name returned by this.ruleProperty() is always an array of the form:
|
|
// [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"]
|
|
// where each item is a tree.Keyword or tree.Variable
|
|
merge = !isVariable && name.length > 1 && name.pop().value; // Custom property values get permissive parsing
|
|
|
|
if (name[0].value && name[0].value.slice(0, 2) === '--') {
|
|
value = this.permissiveValue();
|
|
} // Try to store values as anonymous
|
|
// If we need the value later we'll re-parse it in ruleset.parseValue
|
|
else {
|
|
value = this.anonymousValue();
|
|
}
|
|
|
|
if (value) {
|
|
parserInput.forget(); // anonymous values absorb the end ';' which is required for them to work
|
|
|
|
return new tree.Declaration(name, value, false, merge, index, fileInfo);
|
|
}
|
|
|
|
if (!value) {
|
|
value = this.value();
|
|
}
|
|
|
|
if (value) {
|
|
important = this.important();
|
|
} else if (isVariable) {
|
|
// As a last resort, try permissiveValue
|
|
value = this.permissiveValue();
|
|
}
|
|
}
|
|
|
|
if (value && (this.end() || hasDR)) {
|
|
parserInput.forget();
|
|
return new tree.Declaration(name, value, important, merge, index, fileInfo);
|
|
} else {
|
|
parserInput.restore();
|
|
}
|
|
} else {
|
|
parserInput.restore();
|
|
}
|
|
},
|
|
anonymousValue: function anonymousValue() {
|
|
var index = parserInput.i;
|
|
var match = parserInput.$re(/^([^.#@\$+\/'"*`(;{}-]*);/);
|
|
|
|
if (match) {
|
|
return new tree.Anonymous(match[1], index);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Used for custom properties, at-rules, and variables (as fallback)
|
|
* Parses almost anything inside of {} [] () "" blocks
|
|
* until it reaches outer-most tokens.
|
|
*
|
|
* First, it will try to parse comments and entities to reach
|
|
* the end. This is mostly like the Expression parser except no
|
|
* math is allowed.
|
|
*/
|
|
permissiveValue: function permissiveValue(untilTokens) {
|
|
var i;
|
|
var e;
|
|
var done;
|
|
var value;
|
|
var tok = untilTokens || ';';
|
|
var index = parserInput.i;
|
|
var result = [];
|
|
|
|
function testCurrentChar() {
|
|
var char = parserInput.currentChar();
|
|
|
|
if (typeof tok === 'string') {
|
|
return char === tok;
|
|
} else {
|
|
return tok.test(char);
|
|
}
|
|
}
|
|
|
|
if (testCurrentChar()) {
|
|
return;
|
|
}
|
|
|
|
value = [];
|
|
|
|
do {
|
|
e = this.comment();
|
|
|
|
if (e) {
|
|
value.push(e);
|
|
continue;
|
|
}
|
|
|
|
e = this.entity();
|
|
|
|
if (e) {
|
|
value.push(e);
|
|
}
|
|
} while (e);
|
|
|
|
done = testCurrentChar();
|
|
|
|
if (value.length > 0) {
|
|
value = new tree.Expression(value);
|
|
|
|
if (done) {
|
|
return value;
|
|
} else {
|
|
result.push(value);
|
|
} // Preserve space before $parseUntil as it will not
|
|
|
|
|
|
if (parserInput.prevChar() === ' ') {
|
|
result.push(new tree.Anonymous(' ', index));
|
|
}
|
|
}
|
|
|
|
parserInput.save();
|
|
value = parserInput.$parseUntil(tok);
|
|
|
|
if (value) {
|
|
if (typeof value === 'string') {
|
|
error(`Expected '${value}'`, 'Parse');
|
|
}
|
|
|
|
if (value.length === 1 && value[0] === ' ') {
|
|
parserInput.forget();
|
|
return new tree.Anonymous('', index);
|
|
}
|
|
|
|
var item;
|
|
|
|
for (i = 0; i < value.length; i++) {
|
|
item = value[i];
|
|
|
|
if (Array.isArray(item)) {
|
|
// Treat actual quotes as normal quoted values
|
|
result.push(new tree.Quoted(item[0], item[1], true, index, fileInfo));
|
|
} else {
|
|
if (i === value.length - 1) {
|
|
item = item.trim();
|
|
} // Treat like quoted values, but replace vars like unquoted expressions
|
|
|
|
|
|
var quote = new tree.Quoted('\'', item, true, index, fileInfo);
|
|
quote.variableRegex = /@([\w-]+)/g;
|
|
quote.propRegex = /\$([\w-]+)/g;
|
|
result.push(quote);
|
|
}
|
|
}
|
|
|
|
parserInput.forget();
|
|
return new tree.Expression(result, true);
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
//
|
|
// An @import atrule
|
|
//
|
|
// @import "lib";
|
|
//
|
|
// Depending on our environment, importing is done differently:
|
|
// In the browser, it's an XHR request, in Node, it would be a
|
|
// file-system operation. The function used for importing is
|
|
// stored in `import`, which we pass to the Import constructor.
|
|
//
|
|
'import': function _import() {
|
|
var path;
|
|
var features;
|
|
var index = parserInput.i;
|
|
var dir = parserInput.$re(/^@import?\s+/);
|
|
|
|
if (dir) {
|
|
var options = (dir ? this.importOptions() : null) || {};
|
|
|
|
if (path = this.entities.quoted() || this.entities.url()) {
|
|
features = this.mediaFeatures();
|
|
|
|
if (!parserInput.$char(';')) {
|
|
parserInput.i = index;
|
|
error('missing semi-colon or unrecognised media features on import');
|
|
}
|
|
|
|
features = features && new tree.Value(features);
|
|
return new tree.Import(path, features, options, index, fileInfo);
|
|
} else {
|
|
parserInput.i = index;
|
|
error('malformed import statement');
|
|
}
|
|
}
|
|
},
|
|
importOptions: function importOptions() {
|
|
var o;
|
|
var options = {};
|
|
var optionName;
|
|
var value; // list of options, surrounded by parens
|
|
|
|
if (!parserInput.$char('(')) {
|
|
return null;
|
|
}
|
|
|
|
do {
|
|
o = this.importOption();
|
|
|
|
if (o) {
|
|
optionName = o;
|
|
value = true;
|
|
|
|
switch (optionName) {
|
|
case 'css':
|
|
optionName = 'less';
|
|
value = false;
|
|
break;
|
|
|
|
case 'once':
|
|
optionName = 'multiple';
|
|
value = false;
|
|
break;
|
|
}
|
|
|
|
options[optionName] = value;
|
|
|
|
if (!parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
}
|
|
} while (o);
|
|
|
|
expectChar(')');
|
|
return options;
|
|
},
|
|
importOption: function importOption() {
|
|
var opt = parserInput.$re(/^(less|css|multiple|once|inline|reference|optional)/);
|
|
|
|
if (opt) {
|
|
return opt[1];
|
|
}
|
|
},
|
|
mediaFeature: function mediaFeature() {
|
|
var entities = this.entities;
|
|
var nodes = [];
|
|
var e;
|
|
var p;
|
|
parserInput.save();
|
|
|
|
do {
|
|
e = entities.keyword() || entities.variable() || entities.mixinLookup();
|
|
|
|
if (e) {
|
|
nodes.push(e);
|
|
} else if (parserInput.$char('(')) {
|
|
p = this.property();
|
|
e = this.value();
|
|
|
|
if (parserInput.$char(')')) {
|
|
if (p && e) {
|
|
nodes.push(new tree.Paren(new tree.Declaration(p, e, null, null, parserInput.i, fileInfo, true)));
|
|
} else if (e) {
|
|
nodes.push(new tree.Paren(e));
|
|
} else {
|
|
error('badly formed media feature definition');
|
|
}
|
|
} else {
|
|
error('Missing closing \')\'', 'Parse');
|
|
}
|
|
}
|
|
} while (e);
|
|
|
|
parserInput.forget();
|
|
|
|
if (nodes.length > 0) {
|
|
return new tree.Expression(nodes);
|
|
}
|
|
},
|
|
mediaFeatures: function mediaFeatures() {
|
|
var entities = this.entities;
|
|
var features = [];
|
|
var e;
|
|
|
|
do {
|
|
e = this.mediaFeature();
|
|
|
|
if (e) {
|
|
features.push(e);
|
|
|
|
if (!parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
} else {
|
|
e = entities.variable() || entities.mixinLookup();
|
|
|
|
if (e) {
|
|
features.push(e);
|
|
|
|
if (!parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while (e);
|
|
|
|
return features.length > 0 ? features : null;
|
|
},
|
|
media: function media() {
|
|
var features;
|
|
var rules;
|
|
var media;
|
|
var debugInfo;
|
|
var index = parserInput.i;
|
|
|
|
if (context.dumpLineNumbers) {
|
|
debugInfo = getDebugInfo(index);
|
|
}
|
|
|
|
parserInput.save();
|
|
|
|
if (parserInput.$str('@media')) {
|
|
features = this.mediaFeatures();
|
|
rules = this.block();
|
|
|
|
if (!rules) {
|
|
error('media definitions require block statements after any features');
|
|
}
|
|
|
|
parserInput.forget();
|
|
media = new tree.Media(rules, features, index, fileInfo);
|
|
|
|
if (context.dumpLineNumbers) {
|
|
media.debugInfo = debugInfo;
|
|
}
|
|
|
|
return media;
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
//
|
|
// A @plugin directive, used to import plugins dynamically.
|
|
//
|
|
// @plugin (args) "lib";
|
|
//
|
|
plugin: function plugin() {
|
|
var path;
|
|
var args;
|
|
var options;
|
|
var index = parserInput.i;
|
|
var dir = parserInput.$re(/^@plugin?\s+/);
|
|
|
|
if (dir) {
|
|
args = this.pluginArgs();
|
|
|
|
if (args) {
|
|
options = {
|
|
pluginArgs: args,
|
|
isPlugin: true
|
|
};
|
|
} else {
|
|
options = {
|
|
isPlugin: true
|
|
};
|
|
}
|
|
|
|
if (path = this.entities.quoted() || this.entities.url()) {
|
|
if (!parserInput.$char(';')) {
|
|
parserInput.i = index;
|
|
error('missing semi-colon on @plugin');
|
|
}
|
|
|
|
return new tree.Import(path, null, options, index, fileInfo);
|
|
} else {
|
|
parserInput.i = index;
|
|
error('malformed @plugin statement');
|
|
}
|
|
}
|
|
},
|
|
pluginArgs: function pluginArgs() {
|
|
// list of options, surrounded by parens
|
|
parserInput.save();
|
|
|
|
if (!parserInput.$char('(')) {
|
|
parserInput.restore();
|
|
return null;
|
|
}
|
|
|
|
var args = parserInput.$re(/^\s*([^\);]+)\)\s*/);
|
|
|
|
if (args[1]) {
|
|
parserInput.forget();
|
|
return args[1].trim();
|
|
} else {
|
|
parserInput.restore();
|
|
return null;
|
|
}
|
|
},
|
|
//
|
|
// A CSS AtRule
|
|
//
|
|
// @charset "utf-8";
|
|
//
|
|
atrule: function atrule() {
|
|
var index = parserInput.i;
|
|
var name;
|
|
var value;
|
|
var rules;
|
|
var nonVendorSpecificName;
|
|
var hasIdentifier;
|
|
var hasExpression;
|
|
var hasUnknown;
|
|
var hasBlock = true;
|
|
var isRooted = true;
|
|
|
|
if (parserInput.currentChar() !== '@') {
|
|
return;
|
|
}
|
|
|
|
value = this['import']() || this.plugin() || this.media();
|
|
|
|
if (value) {
|
|
return value;
|
|
}
|
|
|
|
parserInput.save();
|
|
name = parserInput.$re(/^@[a-z-]+/);
|
|
|
|
if (!name) {
|
|
return;
|
|
}
|
|
|
|
nonVendorSpecificName = name;
|
|
|
|
if (name.charAt(1) == '-' && name.indexOf('-', 2) > 0) {
|
|
nonVendorSpecificName = `@${name.slice(name.indexOf('-', 2) + 1)}`;
|
|
}
|
|
|
|
switch (nonVendorSpecificName) {
|
|
case '@charset':
|
|
hasIdentifier = true;
|
|
hasBlock = false;
|
|
break;
|
|
|
|
case '@namespace':
|
|
hasExpression = true;
|
|
hasBlock = false;
|
|
break;
|
|
|
|
case '@keyframes':
|
|
case '@counter-style':
|
|
hasIdentifier = true;
|
|
break;
|
|
|
|
case '@document':
|
|
case '@supports':
|
|
hasUnknown = true;
|
|
isRooted = false;
|
|
break;
|
|
|
|
default:
|
|
hasUnknown = true;
|
|
break;
|
|
}
|
|
|
|
parserInput.commentStore.length = 0;
|
|
|
|
if (hasIdentifier) {
|
|
value = this.entity();
|
|
|
|
if (!value) {
|
|
error(`expected ${name} identifier`);
|
|
}
|
|
} else if (hasExpression) {
|
|
value = this.expression();
|
|
|
|
if (!value) {
|
|
error(`expected ${name} expression`);
|
|
}
|
|
} else if (hasUnknown) {
|
|
value = this.permissiveValue(/^[{;]/);
|
|
hasBlock = parserInput.currentChar() === '{';
|
|
|
|
if (!value) {
|
|
if (!hasBlock && parserInput.currentChar() !== ';') {
|
|
error(`${name} rule is missing block or ending semi-colon`);
|
|
}
|
|
} else if (!value.value) {
|
|
value = null;
|
|
}
|
|
}
|
|
|
|
if (hasBlock) {
|
|
rules = this.blockRuleset();
|
|
}
|
|
|
|
if (rules || !hasBlock && value && parserInput.$char(';')) {
|
|
parserInput.forget();
|
|
return new tree.AtRule(name, value, rules, index, fileInfo, context.dumpLineNumbers ? getDebugInfo(index) : null, isRooted);
|
|
}
|
|
|
|
parserInput.restore('at-rule options not recognised');
|
|
},
|
|
//
|
|
// A Value is a comma-delimited list of Expressions
|
|
//
|
|
// font-family: Baskerville, Georgia, serif;
|
|
//
|
|
// In a Rule, a Value represents everything after the `:`,
|
|
// and before the `;`.
|
|
//
|
|
value: function value() {
|
|
var e;
|
|
var expressions = [];
|
|
var index = parserInput.i;
|
|
|
|
do {
|
|
e = this.expression();
|
|
|
|
if (e) {
|
|
expressions.push(e);
|
|
|
|
if (!parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
}
|
|
} while (e);
|
|
|
|
if (expressions.length > 0) {
|
|
return new tree.Value(expressions, index);
|
|
}
|
|
},
|
|
important: function important() {
|
|
if (parserInput.currentChar() === '!') {
|
|
return parserInput.$re(/^! *important/);
|
|
}
|
|
},
|
|
sub: function sub() {
|
|
var a;
|
|
var e;
|
|
parserInput.save();
|
|
|
|
if (parserInput.$char('(')) {
|
|
a = this.addition();
|
|
|
|
if (a && parserInput.$char(')')) {
|
|
parserInput.forget();
|
|
e = new tree.Expression([a]);
|
|
e.parens = true;
|
|
return e;
|
|
}
|
|
|
|
parserInput.restore('Expected \')\'');
|
|
return;
|
|
}
|
|
|
|
parserInput.restore();
|
|
},
|
|
multiplication: function multiplication() {
|
|
var m;
|
|
var a;
|
|
var op;
|
|
var operation;
|
|
var isSpaced;
|
|
m = this.operand();
|
|
|
|
if (m) {
|
|
isSpaced = parserInput.isWhitespace(-1);
|
|
|
|
while (true) {
|
|
if (parserInput.peek(/^\/[*\/]/)) {
|
|
break;
|
|
}
|
|
|
|
parserInput.save();
|
|
op = parserInput.$char('/') || parserInput.$char('*') || parserInput.$str('./');
|
|
|
|
if (!op) {
|
|
parserInput.forget();
|
|
break;
|
|
}
|
|
|
|
a = this.operand();
|
|
|
|
if (!a) {
|
|
parserInput.restore();
|
|
break;
|
|
}
|
|
|
|
parserInput.forget();
|
|
m.parensInOp = true;
|
|
a.parensInOp = true;
|
|
operation = new tree.Operation(op, [operation || m, a], isSpaced);
|
|
isSpaced = parserInput.isWhitespace(-1);
|
|
}
|
|
|
|
return operation || m;
|
|
}
|
|
},
|
|
addition: function addition() {
|
|
var m;
|
|
var a;
|
|
var op;
|
|
var operation;
|
|
var isSpaced;
|
|
m = this.multiplication();
|
|
|
|
if (m) {
|
|
isSpaced = parserInput.isWhitespace(-1);
|
|
|
|
while (true) {
|
|
op = parserInput.$re(/^[-+]\s+/) || !isSpaced && (parserInput.$char('+') || parserInput.$char('-'));
|
|
|
|
if (!op) {
|
|
break;
|
|
}
|
|
|
|
a = this.multiplication();
|
|
|
|
if (!a) {
|
|
break;
|
|
}
|
|
|
|
m.parensInOp = true;
|
|
a.parensInOp = true;
|
|
operation = new tree.Operation(op, [operation || m, a], isSpaced);
|
|
isSpaced = parserInput.isWhitespace(-1);
|
|
}
|
|
|
|
return operation || m;
|
|
}
|
|
},
|
|
conditions: function conditions() {
|
|
var a;
|
|
var b;
|
|
var index = parserInput.i;
|
|
var condition;
|
|
a = this.condition(true);
|
|
|
|
if (a) {
|
|
while (true) {
|
|
if (!parserInput.peek(/^,\s*(not\s*)?\(/) || !parserInput.$char(',')) {
|
|
break;
|
|
}
|
|
|
|
b = this.condition(true);
|
|
|
|
if (!b) {
|
|
break;
|
|
}
|
|
|
|
condition = new tree.Condition('or', condition || a, b, index);
|
|
}
|
|
|
|
return condition || a;
|
|
}
|
|
},
|
|
condition: function condition(needsParens) {
|
|
var result;
|
|
var logical;
|
|
var next;
|
|
|
|
function or() {
|
|
return parserInput.$str('or');
|
|
}
|
|
|
|
result = this.conditionAnd(needsParens);
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
logical = or();
|
|
|
|
if (logical) {
|
|
next = this.condition(needsParens);
|
|
|
|
if (next) {
|
|
result = new tree.Condition(logical, result, next);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
},
|
|
conditionAnd: function conditionAnd(needsParens) {
|
|
var result;
|
|
var logical;
|
|
var next;
|
|
var self = this;
|
|
|
|
function insideCondition() {
|
|
var cond = self.negatedCondition(needsParens) || self.parenthesisCondition(needsParens);
|
|
|
|
if (!cond && !needsParens) {
|
|
return self.atomicCondition(needsParens);
|
|
}
|
|
|
|
return cond;
|
|
}
|
|
|
|
function and() {
|
|
return parserInput.$str('and');
|
|
}
|
|
|
|
result = insideCondition();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
logical = and();
|
|
|
|
if (logical) {
|
|
next = this.conditionAnd(needsParens);
|
|
|
|
if (next) {
|
|
result = new tree.Condition(logical, result, next);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
},
|
|
negatedCondition: function negatedCondition(needsParens) {
|
|
if (parserInput.$str('not')) {
|
|
var result = this.parenthesisCondition(needsParens);
|
|
|
|
if (result) {
|
|
result.negate = !result.negate;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
},
|
|
parenthesisCondition: function parenthesisCondition(needsParens) {
|
|
function tryConditionFollowedByParenthesis(me) {
|
|
var body;
|
|
parserInput.save();
|
|
body = me.condition(needsParens);
|
|
|
|
if (!body) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (!parserInput.$char(')')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
parserInput.forget();
|
|
return body;
|
|
}
|
|
|
|
var body;
|
|
parserInput.save();
|
|
|
|
if (!parserInput.$str('(')) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
body = tryConditionFollowedByParenthesis(this);
|
|
|
|
if (body) {
|
|
parserInput.forget();
|
|
return body;
|
|
}
|
|
|
|
body = this.atomicCondition(needsParens);
|
|
|
|
if (!body) {
|
|
parserInput.restore();
|
|
return;
|
|
}
|
|
|
|
if (!parserInput.$char(')')) {
|
|
parserInput.restore(`expected ')' got '${parserInput.currentChar()}'`);
|
|
return;
|
|
}
|
|
|
|
parserInput.forget();
|
|
return body;
|
|
},
|
|
atomicCondition: function atomicCondition(needsParens) {
|
|
var entities = this.entities;
|
|
var index = parserInput.i;
|
|
var a;
|
|
var b;
|
|
var c;
|
|
var op;
|
|
|
|
function cond() {
|
|
return this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
|
|
}
|
|
|
|
cond = cond.bind(this);
|
|
a = cond();
|
|
|
|
if (a) {
|
|
if (parserInput.$char('>')) {
|
|
if (parserInput.$char('=')) {
|
|
op = '>=';
|
|
} else {
|
|
op = '>';
|
|
}
|
|
} else if (parserInput.$char('<')) {
|
|
if (parserInput.$char('=')) {
|
|
op = '<=';
|
|
} else {
|
|
op = '<';
|
|
}
|
|
} else if (parserInput.$char('=')) {
|
|
if (parserInput.$char('>')) {
|
|
op = '=>';
|
|
} else if (parserInput.$char('<')) {
|
|
op = '=<';
|
|
} else {
|
|
op = '=';
|
|
}
|
|
}
|
|
|
|
if (op) {
|
|
b = cond();
|
|
|
|
if (b) {
|
|
c = new tree.Condition(op, a, b, index, false);
|
|
} else {
|
|
error('expected expression');
|
|
}
|
|
} else {
|
|
c = new tree.Condition('=', a, new tree.Keyword('true'), index, false);
|
|
}
|
|
|
|
return c;
|
|
}
|
|
},
|
|
//
|
|
// An operand is anything that can be part of an operation,
|
|
// such as a Color, or a Variable
|
|
//
|
|
operand: function operand() {
|
|
var entities = this.entities;
|
|
var negate;
|
|
|
|
if (parserInput.peek(/^-[@\$\(]/)) {
|
|
negate = parserInput.$char('-');
|
|
}
|
|
|
|
var o = this.sub() || entities.dimension() || entities.color() || entities.variable() || entities.property() || entities.call() || entities.quoted(true) || entities.colorKeyword() || entities.mixinLookup();
|
|
|
|
if (negate) {
|
|
o.parensInOp = true;
|
|
o = new tree.Negative(o);
|
|
}
|
|
|
|
return o;
|
|
},
|
|
//
|
|
// Expressions either represent mathematical operations,
|
|
// or white-space delimited Entities.
|
|
//
|
|
// 1px solid black
|
|
// @var * 2
|
|
//
|
|
expression: function expression() {
|
|
var entities = [];
|
|
var e;
|
|
var delim;
|
|
var index = parserInput.i;
|
|
|
|
do {
|
|
e = this.comment();
|
|
|
|
if (e) {
|
|
entities.push(e);
|
|
continue;
|
|
}
|
|
|
|
e = this.addition() || this.entity();
|
|
|
|
if (e) {
|
|
entities.push(e); // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here
|
|
|
|
if (!parserInput.peek(/^\/[\/*]/)) {
|
|
delim = parserInput.$char('/');
|
|
|
|
if (delim) {
|
|
entities.push(new tree.Anonymous(delim, index));
|
|
}
|
|
}
|
|
}
|
|
} while (e);
|
|
|
|
if (entities.length > 0) {
|
|
return new tree.Expression(entities);
|
|
}
|
|
},
|
|
property: function property() {
|
|
var name = parserInput.$re(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/);
|
|
|
|
if (name) {
|
|
return name[1];
|
|
}
|
|
},
|
|
ruleProperty: function ruleProperty() {
|
|
var name = [];
|
|
var index = [];
|
|
var s;
|
|
var k;
|
|
parserInput.save();
|
|
var simpleProperty = parserInput.$re(/^([_a-zA-Z0-9-]+)\s*:/);
|
|
|
|
if (simpleProperty) {
|
|
name = [new tree.Keyword(simpleProperty[1])];
|
|
parserInput.forget();
|
|
return name;
|
|
}
|
|
|
|
function match(re) {
|
|
var i = parserInput.i;
|
|
var chunk = parserInput.$re(re);
|
|
|
|
if (chunk) {
|
|
index.push(i);
|
|
return name.push(chunk[1]);
|
|
}
|
|
}
|
|
|
|
match(/^(\*?)/);
|
|
|
|
while (true) {
|
|
if (!match(/^((?:[\w-]+)|(?:[@\$]\{[\w-]+\}))/)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (name.length > 1 && match(/^((?:\+_|\+)?)\s*:/)) {
|
|
parserInput.forget(); // at last, we have the complete match now. move forward,
|
|
// convert name particles to tree objects and return:
|
|
|
|
if (name[0] === '') {
|
|
name.shift();
|
|
index.shift();
|
|
}
|
|
|
|
for (k = 0; k < name.length; k++) {
|
|
s = name[k];
|
|
name[k] = s.charAt(0) !== '@' && s.charAt(0) !== '$' ? new tree.Keyword(s) : s.charAt(0) === '@' ? new tree.Variable(`@${s.slice(2, -1)}`, index[k], fileInfo) : new tree.Property(`$${s.slice(2, -1)}`, index[k], fileInfo);
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
parserInput.restore();
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
Parser.serializeVars = function (vars) {
|
|
var s = '';
|
|
|
|
for (var name in vars) {
|
|
if (Object.hasOwnProperty.call(vars, name)) {
|
|
var value = vars[name];
|
|
s += `${(name[0] === '@' ? '' : '@') + name}: ${value}${String(value).slice(-1) === ';' ? '' : ';'}`;
|
|
}
|
|
}
|
|
|
|
return s;
|
|
};
|
|
|
|
function boolean(condition) {
|
|
return condition ? Keyword.True : Keyword.False;
|
|
}
|
|
|
|
function If(condition, trueValue, falseValue) {
|
|
return condition ? trueValue : falseValue || new Anonymous();
|
|
}
|
|
|
|
var boolean$1 = {
|
|
boolean,
|
|
'if': If
|
|
};
|
|
|
|
var colorFunctions;
|
|
|
|
function clamp$1(val) {
|
|
return Math.min(1, Math.max(0, val));
|
|
}
|
|
|
|
function hsla(origColor, hsl) {
|
|
var color = colorFunctions.hsla(hsl.h, hsl.s, hsl.l, hsl.a);
|
|
|
|
if (color) {
|
|
if (origColor.value && /^(rgb|hsl)/.test(origColor.value)) {
|
|
color.value = origColor.value;
|
|
} else {
|
|
color.value = 'rgb';
|
|
}
|
|
|
|
return color;
|
|
}
|
|
}
|
|
|
|
function toHSL(color) {
|
|
if (color.toHSL) {
|
|
return color.toHSL();
|
|
} else {
|
|
throw new Error('Argument cannot be evaluated to a color');
|
|
}
|
|
}
|
|
|
|
function toHSV(color) {
|
|
if (color.toHSV) {
|
|
return color.toHSV();
|
|
} else {
|
|
throw new Error('Argument cannot be evaluated to a color');
|
|
}
|
|
}
|
|
|
|
function number(n) {
|
|
if (n instanceof Dimension) {
|
|
return parseFloat(n.unit.is('%') ? n.value / 100 : n.value);
|
|
} else if (typeof n === 'number') {
|
|
return n;
|
|
} else {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'color functions take numbers as parameters'
|
|
};
|
|
}
|
|
}
|
|
|
|
function scaled(n, size) {
|
|
if (n instanceof Dimension && n.unit.is('%')) {
|
|
return parseFloat(n.value * size / 100);
|
|
} else {
|
|
return number(n);
|
|
}
|
|
}
|
|
|
|
colorFunctions = {
|
|
rgb: function rgb(r, g, b) {
|
|
var color = colorFunctions.rgba(r, g, b, 1.0);
|
|
|
|
if (color) {
|
|
color.value = 'rgb';
|
|
return color;
|
|
}
|
|
},
|
|
rgba: function rgba(r, g, b, a) {
|
|
try {
|
|
if (r instanceof Color) {
|
|
if (g) {
|
|
a = number(g);
|
|
} else {
|
|
a = r.alpha;
|
|
}
|
|
|
|
return new Color(r.rgb, a, 'rgba');
|
|
}
|
|
|
|
var rgb = [r, g, b].map(function (c) {
|
|
return scaled(c, 255);
|
|
});
|
|
a = number(a);
|
|
return new Color(rgb, a, 'rgba');
|
|
} catch (e) {}
|
|
},
|
|
hsl: function hsl(h, s, l) {
|
|
var color = colorFunctions.hsla(h, s, l, 1.0);
|
|
|
|
if (color) {
|
|
color.value = 'hsl';
|
|
return color;
|
|
}
|
|
},
|
|
hsla: function hsla(h, s, l, a) {
|
|
try {
|
|
if (h instanceof Color) {
|
|
if (s) {
|
|
a = number(s);
|
|
} else {
|
|
a = h.alpha;
|
|
}
|
|
|
|
return new Color(h.rgb, a, 'hsla');
|
|
}
|
|
|
|
var m1;
|
|
var m2;
|
|
|
|
function hue(h) {
|
|
h = h < 0 ? h + 1 : h > 1 ? h - 1 : h;
|
|
|
|
if (h * 6 < 1) {
|
|
return m1 + (m2 - m1) * h * 6;
|
|
} else if (h * 2 < 1) {
|
|
return m2;
|
|
} else if (h * 3 < 2) {
|
|
return m1 + (m2 - m1) * (2 / 3 - h) * 6;
|
|
} else {
|
|
return m1;
|
|
}
|
|
}
|
|
|
|
h = number(h) % 360 / 360;
|
|
s = clamp$1(number(s));
|
|
l = clamp$1(number(l));
|
|
a = clamp$1(number(a));
|
|
m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
|
|
m1 = l * 2 - m2;
|
|
var rgb = [hue(h + 1 / 3) * 255, hue(h) * 255, hue(h - 1 / 3) * 255];
|
|
a = number(a);
|
|
return new Color(rgb, a, 'hsla');
|
|
} catch (e) {}
|
|
},
|
|
hsv: function hsv(h, s, v) {
|
|
return colorFunctions.hsva(h, s, v, 1.0);
|
|
},
|
|
hsva: function hsva(h, s, v, a) {
|
|
h = number(h) % 360 / 360 * 360;
|
|
s = number(s);
|
|
v = number(v);
|
|
a = number(a);
|
|
var i;
|
|
var f;
|
|
i = Math.floor(h / 60 % 6);
|
|
f = h / 60 - i;
|
|
var vs = [v, v * (1 - s), v * (1 - f * s), v * (1 - (1 - f) * s)];
|
|
var perm = [[0, 3, 1], [2, 0, 1], [1, 0, 3], [1, 2, 0], [3, 1, 0], [0, 1, 2]];
|
|
return colorFunctions.rgba(vs[perm[i][0]] * 255, vs[perm[i][1]] * 255, vs[perm[i][2]] * 255, a);
|
|
},
|
|
hue: function hue(color) {
|
|
return new Dimension(toHSL(color).h);
|
|
},
|
|
saturation: function saturation(color) {
|
|
return new Dimension(toHSL(color).s * 100, '%');
|
|
},
|
|
lightness: function lightness(color) {
|
|
return new Dimension(toHSL(color).l * 100, '%');
|
|
},
|
|
hsvhue: function hsvhue(color) {
|
|
return new Dimension(toHSV(color).h);
|
|
},
|
|
hsvsaturation: function hsvsaturation(color) {
|
|
return new Dimension(toHSV(color).s * 100, '%');
|
|
},
|
|
hsvvalue: function hsvvalue(color) {
|
|
return new Dimension(toHSV(color).v * 100, '%');
|
|
},
|
|
red: function red(color) {
|
|
return new Dimension(color.rgb[0]);
|
|
},
|
|
green: function green(color) {
|
|
return new Dimension(color.rgb[1]);
|
|
},
|
|
blue: function blue(color) {
|
|
return new Dimension(color.rgb[2]);
|
|
},
|
|
alpha: function alpha(color) {
|
|
return new Dimension(toHSL(color).a);
|
|
},
|
|
luma: function luma(color) {
|
|
return new Dimension(color.luma() * color.alpha * 100, '%');
|
|
},
|
|
luminance: function luminance(color) {
|
|
var luminance = 0.2126 * color.rgb[0] / 255 + 0.7152 * color.rgb[1] / 255 + 0.0722 * color.rgb[2] / 255;
|
|
return new Dimension(luminance * color.alpha * 100, '%');
|
|
},
|
|
saturate: function saturate(color, amount, method) {
|
|
// filter: saturate(3.2);
|
|
// should be kept as is, so check for color
|
|
if (!color.rgb) {
|
|
return null;
|
|
}
|
|
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.s += hsl.s * amount.value / 100;
|
|
} else {
|
|
hsl.s += amount.value / 100;
|
|
}
|
|
|
|
hsl.s = clamp$1(hsl.s);
|
|
return hsla(color, hsl);
|
|
},
|
|
desaturate: function desaturate(color, amount, method) {
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.s -= hsl.s * amount.value / 100;
|
|
} else {
|
|
hsl.s -= amount.value / 100;
|
|
}
|
|
|
|
hsl.s = clamp$1(hsl.s);
|
|
return hsla(color, hsl);
|
|
},
|
|
lighten: function lighten(color, amount, method) {
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.l += hsl.l * amount.value / 100;
|
|
} else {
|
|
hsl.l += amount.value / 100;
|
|
}
|
|
|
|
hsl.l = clamp$1(hsl.l);
|
|
return hsla(color, hsl);
|
|
},
|
|
darken: function darken(color, amount, method) {
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.l -= hsl.l * amount.value / 100;
|
|
} else {
|
|
hsl.l -= amount.value / 100;
|
|
}
|
|
|
|
hsl.l = clamp$1(hsl.l);
|
|
return hsla(color, hsl);
|
|
},
|
|
fadein: function fadein(color, amount, method) {
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.a += hsl.a * amount.value / 100;
|
|
} else {
|
|
hsl.a += amount.value / 100;
|
|
}
|
|
|
|
hsl.a = clamp$1(hsl.a);
|
|
return hsla(color, hsl);
|
|
},
|
|
fadeout: function fadeout(color, amount, method) {
|
|
var hsl = toHSL(color);
|
|
|
|
if (typeof method !== 'undefined' && method.value === 'relative') {
|
|
hsl.a -= hsl.a * amount.value / 100;
|
|
} else {
|
|
hsl.a -= amount.value / 100;
|
|
}
|
|
|
|
hsl.a = clamp$1(hsl.a);
|
|
return hsla(color, hsl);
|
|
},
|
|
fade: function fade(color, amount) {
|
|
var hsl = toHSL(color);
|
|
hsl.a = amount.value / 100;
|
|
hsl.a = clamp$1(hsl.a);
|
|
return hsla(color, hsl);
|
|
},
|
|
spin: function spin(color, amount) {
|
|
var hsl = toHSL(color);
|
|
var hue = (hsl.h + amount.value) % 360;
|
|
hsl.h = hue < 0 ? 360 + hue : hue;
|
|
return hsla(color, hsl);
|
|
},
|
|
//
|
|
// Copyright (c) 2006-2009 Hampton Catlin, Natalie Weizenbaum, and Chris Eppstein
|
|
// http://sass-lang.com
|
|
//
|
|
mix: function mix(color1, color2, weight) {
|
|
if (!weight) {
|
|
weight = new Dimension(50);
|
|
}
|
|
|
|
var p = weight.value / 100.0;
|
|
var w = p * 2 - 1;
|
|
var a = toHSL(color1).a - toHSL(color2).a;
|
|
var w1 = ((w * a == -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
|
|
var w2 = 1 - w1;
|
|
var rgb = [color1.rgb[0] * w1 + color2.rgb[0] * w2, color1.rgb[1] * w1 + color2.rgb[1] * w2, color1.rgb[2] * w1 + color2.rgb[2] * w2];
|
|
var alpha = color1.alpha * p + color2.alpha * (1 - p);
|
|
return new Color(rgb, alpha);
|
|
},
|
|
greyscale: function greyscale(color) {
|
|
return colorFunctions.desaturate(color, new Dimension(100));
|
|
},
|
|
contrast: function contrast(color, dark, light, threshold) {
|
|
// filter: contrast(3.2);
|
|
// should be kept as is, so check for color
|
|
if (!color.rgb) {
|
|
return null;
|
|
}
|
|
|
|
if (typeof light === 'undefined') {
|
|
light = colorFunctions.rgba(255, 255, 255, 1.0);
|
|
}
|
|
|
|
if (typeof dark === 'undefined') {
|
|
dark = colorFunctions.rgba(0, 0, 0, 1.0);
|
|
} // Figure out which is actually light and dark:
|
|
|
|
|
|
if (dark.luma() > light.luma()) {
|
|
var t = light;
|
|
light = dark;
|
|
dark = t;
|
|
}
|
|
|
|
if (typeof threshold === 'undefined') {
|
|
threshold = 0.43;
|
|
} else {
|
|
threshold = number(threshold);
|
|
}
|
|
|
|
if (color.luma() < threshold) {
|
|
return light;
|
|
} else {
|
|
return dark;
|
|
}
|
|
},
|
|
// Changes made in 2.7.0 - Reverted in 3.0.0
|
|
// contrast: function (color, color1, color2, threshold) {
|
|
// // Return which of `color1` and `color2` has the greatest contrast with `color`
|
|
// // according to the standard WCAG contrast ratio calculation.
|
|
// // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
|
|
// // The threshold param is no longer used, in line with SASS.
|
|
// // filter: contrast(3.2);
|
|
// // should be kept as is, so check for color
|
|
// if (!color.rgb) {
|
|
// return null;
|
|
// }
|
|
// if (typeof color1 === 'undefined') {
|
|
// color1 = colorFunctions.rgba(0, 0, 0, 1.0);
|
|
// }
|
|
// if (typeof color2 === 'undefined') {
|
|
// color2 = colorFunctions.rgba(255, 255, 255, 1.0);
|
|
// }
|
|
// var contrast1, contrast2;
|
|
// var luma = color.luma();
|
|
// var luma1 = color1.luma();
|
|
// var luma2 = color2.luma();
|
|
// // Calculate contrast ratios for each color
|
|
// if (luma > luma1) {
|
|
// contrast1 = (luma + 0.05) / (luma1 + 0.05);
|
|
// } else {
|
|
// contrast1 = (luma1 + 0.05) / (luma + 0.05);
|
|
// }
|
|
// if (luma > luma2) {
|
|
// contrast2 = (luma + 0.05) / (luma2 + 0.05);
|
|
// } else {
|
|
// contrast2 = (luma2 + 0.05) / (luma + 0.05);
|
|
// }
|
|
// if (contrast1 > contrast2) {
|
|
// return color1;
|
|
// } else {
|
|
// return color2;
|
|
// }
|
|
// },
|
|
argb: function argb(color) {
|
|
return new Anonymous(color.toARGB());
|
|
},
|
|
color: function color(c) {
|
|
if (c instanceof Quoted && /^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})$/i.test(c.value)) {
|
|
var val = c.value.slice(1);
|
|
return new Color(val, undefined, `#${val}`);
|
|
}
|
|
|
|
if (c instanceof Color || (c = Color.fromKeyword(c.value))) {
|
|
c.value = undefined;
|
|
return c;
|
|
}
|
|
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'argument must be a color keyword or 3|4|6|8 digit hex e.g. #FFF'
|
|
};
|
|
},
|
|
tint: function tint(color, amount) {
|
|
return colorFunctions.mix(colorFunctions.rgb(255, 255, 255), color, amount);
|
|
},
|
|
shade: function shade(color, amount) {
|
|
return colorFunctions.mix(colorFunctions.rgb(0, 0, 0), color, amount);
|
|
}
|
|
};
|
|
var color = colorFunctions;
|
|
|
|
// ref: http://www.w3.org/TR/compositing-1
|
|
|
|
function colorBlend(mode, color1, color2) {
|
|
var ab = color1.alpha; // result
|
|
|
|
var // backdrop
|
|
cb;
|
|
var as = color2.alpha;
|
|
var // source
|
|
cs;
|
|
var ar;
|
|
var cr;
|
|
var r = [];
|
|
ar = as + ab * (1 - as);
|
|
|
|
for (var i = 0; i < 3; i++) {
|
|
cb = color1.rgb[i] / 255;
|
|
cs = color2.rgb[i] / 255;
|
|
cr = mode(cb, cs);
|
|
|
|
if (ar) {
|
|
cr = (as * cs + ab * (cb - as * (cb + cs - cr))) / ar;
|
|
}
|
|
|
|
r[i] = cr * 255;
|
|
}
|
|
|
|
return new Color(r, ar);
|
|
}
|
|
|
|
var colorBlendModeFunctions = {
|
|
multiply: function multiply(cb, cs) {
|
|
return cb * cs;
|
|
},
|
|
screen: function screen(cb, cs) {
|
|
return cb + cs - cb * cs;
|
|
},
|
|
overlay: function overlay(cb, cs) {
|
|
cb *= 2;
|
|
return cb <= 1 ? colorBlendModeFunctions.multiply(cb, cs) : colorBlendModeFunctions.screen(cb - 1, cs);
|
|
},
|
|
softlight: function softlight(cb, cs) {
|
|
var d = 1;
|
|
var e = cb;
|
|
|
|
if (cs > 0.5) {
|
|
e = 1;
|
|
d = cb > 0.25 ? Math.sqrt(cb) : ((16 * cb - 12) * cb + 4) * cb;
|
|
}
|
|
|
|
return cb - (1 - 2 * cs) * e * (d - cb);
|
|
},
|
|
hardlight: function hardlight(cb, cs) {
|
|
return colorBlendModeFunctions.overlay(cs, cb);
|
|
},
|
|
difference: function difference(cb, cs) {
|
|
return Math.abs(cb - cs);
|
|
},
|
|
exclusion: function exclusion(cb, cs) {
|
|
return cb + cs - 2 * cb * cs;
|
|
},
|
|
// non-w3c functions:
|
|
average: function average(cb, cs) {
|
|
return (cb + cs) / 2;
|
|
},
|
|
negation: function negation(cb, cs) {
|
|
return 1 - Math.abs(cb + cs - 1);
|
|
}
|
|
};
|
|
|
|
for (var f in colorBlendModeFunctions) {
|
|
if (colorBlendModeFunctions.hasOwnProperty(f)) {
|
|
colorBlend[f] = colorBlend.bind(null, colorBlendModeFunctions[f]);
|
|
}
|
|
}
|
|
|
|
var dataUri = (function (environment) {
|
|
var fallback = function fallback(functionThis, node) {
|
|
return new URL(node, functionThis.index, functionThis.currentFileInfo).eval(functionThis.context);
|
|
};
|
|
|
|
return {
|
|
'data-uri': function dataUri(mimetypeNode, filePathNode) {
|
|
if (!filePathNode) {
|
|
filePathNode = mimetypeNode;
|
|
mimetypeNode = null;
|
|
}
|
|
|
|
var mimetype = mimetypeNode && mimetypeNode.value;
|
|
var filePath = filePathNode.value;
|
|
var currentFileInfo = this.currentFileInfo;
|
|
var currentDirectory = currentFileInfo.rewriteUrls ? currentFileInfo.currentDirectory : currentFileInfo.entryPath;
|
|
var fragmentStart = filePath.indexOf('#');
|
|
var fragment = '';
|
|
|
|
if (fragmentStart !== -1) {
|
|
fragment = filePath.slice(fragmentStart);
|
|
filePath = filePath.slice(0, fragmentStart);
|
|
}
|
|
|
|
var context = clone(this.context);
|
|
context.rawBuffer = true;
|
|
var fileManager = environment.getFileManager(filePath, currentDirectory, context, environment, true);
|
|
|
|
if (!fileManager) {
|
|
return fallback(this, filePathNode);
|
|
}
|
|
|
|
var useBase64 = false; // detect the mimetype if not given
|
|
|
|
if (!mimetypeNode) {
|
|
mimetype = environment.mimeLookup(filePath);
|
|
|
|
if (mimetype === 'image/svg+xml') {
|
|
useBase64 = false;
|
|
} else {
|
|
// use base 64 unless it's an ASCII or UTF-8 format
|
|
var charset = environment.charsetLookup(mimetype);
|
|
useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0;
|
|
}
|
|
|
|
if (useBase64) {
|
|
mimetype += ';base64';
|
|
}
|
|
} else {
|
|
useBase64 = /;base64$/.test(mimetype);
|
|
}
|
|
|
|
var fileSync = fileManager.loadFileSync(filePath, currentDirectory, context, environment);
|
|
|
|
if (!fileSync.contents) {
|
|
logger.warn(`Skipped data-uri embedding of ${filePath} because file not found`);
|
|
return fallback(this, filePathNode || mimetypeNode);
|
|
}
|
|
|
|
var buf = fileSync.contents;
|
|
|
|
if (useBase64 && !environment.encodeBase64) {
|
|
return fallback(this, filePathNode);
|
|
}
|
|
|
|
buf = useBase64 ? environment.encodeBase64(buf) : encodeURIComponent(buf);
|
|
var uri = `data:${mimetype},${buf}${fragment}`;
|
|
return new URL(new Quoted(`"${uri}"`, uri, false, this.index, this.currentFileInfo), this.index, this.currentFileInfo);
|
|
}
|
|
};
|
|
});
|
|
|
|
var getItemsFromNode = function getItemsFromNode(node) {
|
|
// handle non-array values as an array of length 1
|
|
// return 'undefined' if index is invalid
|
|
var items = Array.isArray(node.value) ? node.value : Array(node);
|
|
return items;
|
|
};
|
|
|
|
var list = {
|
|
_SELF: function _SELF(n) {
|
|
return n;
|
|
},
|
|
extract: function extract(values, index) {
|
|
// (1-based index)
|
|
index = index.value - 1;
|
|
return getItemsFromNode(values)[index];
|
|
},
|
|
length: function length(values) {
|
|
return new Dimension(getItemsFromNode(values).length);
|
|
},
|
|
|
|
/**
|
|
* Creates a Less list of incremental values.
|
|
* Modeled after Lodash's range function, also exists natively in PHP
|
|
*
|
|
* @param {Dimension} [start=1]
|
|
* @param {Dimension} end - e.g. 10 or 10px - unit is added to output
|
|
* @param {Dimension} [step=1]
|
|
*/
|
|
range: function range(start, end, step) {
|
|
var from;
|
|
var to;
|
|
var stepValue = 1;
|
|
var list = [];
|
|
|
|
if (end) {
|
|
to = end;
|
|
from = start.value;
|
|
|
|
if (step) {
|
|
stepValue = step.value;
|
|
}
|
|
} else {
|
|
from = 1;
|
|
to = start;
|
|
}
|
|
|
|
for (var i = from; i <= to.value; i += stepValue) {
|
|
list.push(new Dimension(i, to.unit));
|
|
}
|
|
|
|
return new Expression(list);
|
|
},
|
|
each: function each(list, rs) {
|
|
var rules = [];
|
|
var newRules;
|
|
var iterator;
|
|
|
|
if (list.value && !(list instanceof Quoted)) {
|
|
if (Array.isArray(list.value)) {
|
|
iterator = list.value;
|
|
} else {
|
|
iterator = [list.value];
|
|
}
|
|
} else if (list.ruleset) {
|
|
iterator = list.ruleset.rules;
|
|
} else if (list.rules) {
|
|
iterator = list.rules;
|
|
} else if (Array.isArray(list)) {
|
|
iterator = list;
|
|
} else {
|
|
iterator = [list];
|
|
}
|
|
|
|
var valueName = '@value';
|
|
var keyName = '@key';
|
|
var indexName = '@index';
|
|
|
|
if (rs.params) {
|
|
valueName = rs.params[0] && rs.params[0].name;
|
|
keyName = rs.params[1] && rs.params[1].name;
|
|
indexName = rs.params[2] && rs.params[2].name;
|
|
rs = rs.rules;
|
|
} else {
|
|
rs = rs.ruleset;
|
|
}
|
|
|
|
for (var i = 0; i < iterator.length; i++) {
|
|
var key = void 0;
|
|
var value = void 0;
|
|
var item = iterator[i];
|
|
|
|
if (item instanceof Declaration) {
|
|
key = typeof item.name === 'string' ? item.name : item.name[0].value;
|
|
value = item.value;
|
|
} else {
|
|
key = new Dimension(i + 1);
|
|
value = item;
|
|
}
|
|
|
|
if (item instanceof Comment) {
|
|
continue;
|
|
}
|
|
|
|
newRules = rs.rules.slice(0);
|
|
|
|
if (valueName) {
|
|
newRules.push(new Declaration(valueName, value, false, false, this.index, this.currentFileInfo));
|
|
}
|
|
|
|
if (indexName) {
|
|
newRules.push(new Declaration(indexName, new Dimension(i + 1), false, false, this.index, this.currentFileInfo));
|
|
}
|
|
|
|
if (keyName) {
|
|
newRules.push(new Declaration(keyName, key, false, false, this.index, this.currentFileInfo));
|
|
}
|
|
|
|
rules.push(new Ruleset([new Selector([new Element("", '&')])], newRules, rs.strictImports, rs.visibilityInfo()));
|
|
}
|
|
|
|
return new Ruleset([new Selector([new Element("", '&')])], rules, rs.strictImports, rs.visibilityInfo()).eval(this.context);
|
|
}
|
|
};
|
|
|
|
var MathHelper = function MathHelper(fn, unit, n) {
|
|
if (!(n instanceof Dimension)) {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'argument must be a number'
|
|
};
|
|
}
|
|
|
|
if (unit == null) {
|
|
unit = n.unit;
|
|
} else {
|
|
n = n.unify();
|
|
}
|
|
|
|
return new Dimension(fn(parseFloat(n.value)), unit);
|
|
};
|
|
|
|
var mathFunctions = {
|
|
// name, unit
|
|
ceil: null,
|
|
floor: null,
|
|
sqrt: null,
|
|
abs: null,
|
|
tan: '',
|
|
sin: '',
|
|
cos: '',
|
|
atan: 'rad',
|
|
asin: 'rad',
|
|
acos: 'rad'
|
|
};
|
|
|
|
for (var f$1 in mathFunctions) {
|
|
if (mathFunctions.hasOwnProperty(f$1)) {
|
|
mathFunctions[f$1] = MathHelper.bind(null, Math[f$1], mathFunctions[f$1]);
|
|
}
|
|
}
|
|
|
|
mathFunctions.round = function (n, f) {
|
|
var fraction = typeof f === 'undefined' ? 0 : f.value;
|
|
return MathHelper(function (num) {
|
|
return num.toFixed(fraction);
|
|
}, null, n);
|
|
};
|
|
|
|
var minMax = function minMax(isMin, args) {
|
|
args = Array.prototype.slice.call(args);
|
|
|
|
switch (args.length) {
|
|
case 0:
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'one or more arguments required'
|
|
};
|
|
}
|
|
|
|
var i; // key is the unit.toString() for unified Dimension values,
|
|
|
|
var j;
|
|
var current;
|
|
var currentUnified;
|
|
var referenceUnified;
|
|
var unit;
|
|
var unitStatic;
|
|
var unitClone;
|
|
var // elems only contains original argument values.
|
|
order = [];
|
|
var values = {}; // value is the index into the order array.
|
|
|
|
for (i = 0; i < args.length; i++) {
|
|
current = args[i];
|
|
|
|
if (!(current instanceof Dimension)) {
|
|
if (Array.isArray(args[i].value)) {
|
|
Array.prototype.push.apply(args, Array.prototype.slice.call(args[i].value));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
currentUnified = current.unit.toString() === '' && unitClone !== undefined ? new Dimension(current.value, unitClone).unify() : current.unify();
|
|
unit = currentUnified.unit.toString() === '' && unitStatic !== undefined ? unitStatic : currentUnified.unit.toString();
|
|
unitStatic = unit !== '' && unitStatic === undefined || unit !== '' && order[0].unify().unit.toString() === '' ? unit : unitStatic;
|
|
unitClone = unit !== '' && unitClone === undefined ? current.unit.toString() : unitClone;
|
|
j = values[''] !== undefined && unit !== '' && unit === unitStatic ? values[''] : values[unit];
|
|
|
|
if (j === undefined) {
|
|
if (unitStatic !== undefined && unit !== unitStatic) {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'incompatible types'
|
|
};
|
|
}
|
|
|
|
values[unit] = order.length;
|
|
order.push(current);
|
|
continue;
|
|
}
|
|
|
|
referenceUnified = order[j].unit.toString() === '' && unitClone !== undefined ? new Dimension(order[j].value, unitClone).unify() : order[j].unify();
|
|
|
|
if (isMin && currentUnified.value < referenceUnified.value || !isMin && currentUnified.value > referenceUnified.value) {
|
|
order[j] = current;
|
|
}
|
|
}
|
|
|
|
if (order.length == 1) {
|
|
return order[0];
|
|
}
|
|
|
|
args = order.map(function (a) {
|
|
return a.toCSS(this.context);
|
|
}).join(this.context.compress ? ',' : ', ');
|
|
return new Anonymous(`${isMin ? 'min' : 'max'}(${args})`);
|
|
};
|
|
|
|
var number$1 = {
|
|
min: function min() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return minMax(true, args);
|
|
},
|
|
max: function max() {
|
|
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
args[_key2] = arguments[_key2];
|
|
}
|
|
|
|
return minMax(false, args);
|
|
},
|
|
convert: function convert(val, unit) {
|
|
return val.convertTo(unit.value);
|
|
},
|
|
pi: function pi() {
|
|
return new Dimension(Math.PI);
|
|
},
|
|
mod: function mod(a, b) {
|
|
return new Dimension(a.value % b.value, a.unit);
|
|
},
|
|
pow: function pow(x, y) {
|
|
if (typeof x === 'number' && typeof y === 'number') {
|
|
x = new Dimension(x);
|
|
y = new Dimension(y);
|
|
} else if (!(x instanceof Dimension) || !(y instanceof Dimension)) {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'arguments must be numbers'
|
|
};
|
|
}
|
|
|
|
return new Dimension(Math.pow(x.value, y.value), x.unit);
|
|
},
|
|
percentage: function percentage(n) {
|
|
var result = MathHelper(function (num) {
|
|
return num * 100;
|
|
}, '%', n);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var string = {
|
|
e: function e(str) {
|
|
return new Quoted('"', str instanceof JavaScript ? str.evaluated : str.value, true);
|
|
},
|
|
escape: function escape(str) {
|
|
return new Anonymous(encodeURI(str.value).replace(/=/g, '%3D').replace(/:/g, '%3A').replace(/#/g, '%23').replace(/;/g, '%3B').replace(/\(/g, '%28').replace(/\)/g, '%29'));
|
|
},
|
|
replace: function replace(string, pattern, replacement, flags) {
|
|
var result = string.value;
|
|
replacement = replacement.type === 'Quoted' ? replacement.value : replacement.toCSS();
|
|
result = result.replace(new RegExp(pattern.value, flags ? flags.value : ''), replacement);
|
|
return new Quoted(string.quote || '', result, string.escaped);
|
|
},
|
|
'%': function _(string
|
|
/* arg, arg, ... */
|
|
) {
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
var result = string.value;
|
|
|
|
var _loop = function _loop(i) {
|
|
/* jshint loopfunc:true */
|
|
result = result.replace(/%[sda]/i, function (token) {
|
|
var value = args[i].type === 'Quoted' && token.match(/s/i) ? args[i].value : args[i].toCSS();
|
|
return token.match(/[A-Z]$/) ? encodeURIComponent(value) : value;
|
|
});
|
|
};
|
|
|
|
for (var i = 0; i < args.length; i++) {
|
|
_loop(i);
|
|
}
|
|
|
|
result = result.replace(/%%/g, '%');
|
|
return new Quoted(string.quote || '', result, string.escaped);
|
|
}
|
|
};
|
|
|
|
var svg = (function (environment) {
|
|
return {
|
|
'svg-gradient': function svgGradient(direction) {
|
|
var stops;
|
|
var gradientDirectionSvg;
|
|
var gradientType = 'linear';
|
|
var rectangleDimension = 'x="0" y="0" width="1" height="1"';
|
|
var renderEnv = {
|
|
compress: false
|
|
};
|
|
var returner;
|
|
var directionValue = direction.toCSS(renderEnv);
|
|
var i;
|
|
var color;
|
|
var position;
|
|
var positionValue;
|
|
var alpha;
|
|
|
|
function throwArgumentDescriptor() {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'svg-gradient expects direction, start_color [start_position], [color position,]...,' + ' end_color [end_position] or direction, color list'
|
|
};
|
|
}
|
|
|
|
if (arguments.length == 2) {
|
|
if (arguments[1].value.length < 2) {
|
|
throwArgumentDescriptor();
|
|
}
|
|
|
|
stops = arguments[1].value;
|
|
} else if (arguments.length < 3) {
|
|
throwArgumentDescriptor();
|
|
} else {
|
|
stops = Array.prototype.slice.call(arguments, 1);
|
|
}
|
|
|
|
switch (directionValue) {
|
|
case 'to bottom':
|
|
gradientDirectionSvg = 'x1="0%" y1="0%" x2="0%" y2="100%"';
|
|
break;
|
|
|
|
case 'to right':
|
|
gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="0%"';
|
|
break;
|
|
|
|
case 'to bottom right':
|
|
gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="100%"';
|
|
break;
|
|
|
|
case 'to top right':
|
|
gradientDirectionSvg = 'x1="0%" y1="100%" x2="100%" y2="0%"';
|
|
break;
|
|
|
|
case 'ellipse':
|
|
case 'ellipse at center':
|
|
gradientType = 'radial';
|
|
gradientDirectionSvg = 'cx="50%" cy="50%" r="75%"';
|
|
rectangleDimension = 'x="-50" y="-50" width="101" height="101"';
|
|
break;
|
|
|
|
default:
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'svg-gradient direction must be \'to bottom\', \'to right\',' + ' \'to bottom right\', \'to top right\' or \'ellipse at center\''
|
|
};
|
|
}
|
|
|
|
returner = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"><${gradientType}Gradient id="g" ${gradientDirectionSvg}>`;
|
|
|
|
for (i = 0; i < stops.length; i += 1) {
|
|
if (stops[i] instanceof Expression) {
|
|
color = stops[i].value[0];
|
|
position = stops[i].value[1];
|
|
} else {
|
|
color = stops[i];
|
|
position = undefined;
|
|
}
|
|
|
|
if (!(color instanceof Color) || !((i === 0 || i + 1 === stops.length) && position === undefined) && !(position instanceof Dimension)) {
|
|
throwArgumentDescriptor();
|
|
}
|
|
|
|
positionValue = position ? position.toCSS(renderEnv) : i === 0 ? '0%' : '100%';
|
|
alpha = color.alpha;
|
|
returner += `<stop offset="${positionValue}" stop-color="${color.toRGB()}"${alpha < 1 ? ` stop-opacity="${alpha}"` : ''}/>`;
|
|
}
|
|
|
|
returner += `</${gradientType}Gradient><rect ${rectangleDimension} fill="url(#g)" /></svg>`;
|
|
returner = encodeURIComponent(returner);
|
|
returner = `data:image/svg+xml,${returner}`;
|
|
return new URL(new Quoted(`'${returner}'`, returner, false, this.index, this.currentFileInfo), this.index, this.currentFileInfo);
|
|
}
|
|
};
|
|
});
|
|
|
|
var isa = function isa(n, Type) {
|
|
return n instanceof Type ? Keyword.True : Keyword.False;
|
|
};
|
|
|
|
var isunit = function isunit(n, unit) {
|
|
if (unit === undefined) {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'missing the required second argument to isunit.'
|
|
};
|
|
}
|
|
|
|
unit = typeof unit.value === 'string' ? unit.value : unit;
|
|
|
|
if (typeof unit !== 'string') {
|
|
throw {
|
|
type: 'Argument',
|
|
message: 'Second argument to isunit should be a unit or a string.'
|
|
};
|
|
}
|
|
|
|
return n instanceof Dimension && n.unit.is(unit) ? Keyword.True : Keyword.False;
|
|
};
|
|
|
|
var types = {
|
|
isruleset: function isruleset(n) {
|
|
return isa(n, DetachedRuleset);
|
|
},
|
|
iscolor: function iscolor(n) {
|
|
return isa(n, Color);
|
|
},
|
|
isnumber: function isnumber(n) {
|
|
return isa(n, Dimension);
|
|
},
|
|
isstring: function isstring(n) {
|
|
return isa(n, Quoted);
|
|
},
|
|
iskeyword: function iskeyword(n) {
|
|
return isa(n, Keyword);
|
|
},
|
|
isurl: function isurl(n) {
|
|
return isa(n, URL);
|
|
},
|
|
ispixel: function ispixel(n) {
|
|
return isunit(n, 'px');
|
|
},
|
|
ispercentage: function ispercentage(n) {
|
|
return isunit(n, '%');
|
|
},
|
|
isem: function isem(n) {
|
|
return isunit(n, 'em');
|
|
},
|
|
isunit,
|
|
unit: function unit(val, _unit) {
|
|
if (!(val instanceof Dimension)) {
|
|
throw {
|
|
type: 'Argument',
|
|
message: `the first argument to unit must be a number${val instanceof Operation ? '. Have you forgotten parenthesis?' : ''}`
|
|
};
|
|
}
|
|
|
|
if (_unit) {
|
|
if (_unit instanceof Keyword) {
|
|
_unit = _unit.value;
|
|
} else {
|
|
_unit = _unit.toCSS();
|
|
}
|
|
} else {
|
|
_unit = '';
|
|
}
|
|
|
|
return new Dimension(val.value, _unit);
|
|
},
|
|
'get-unit': function getUnit(n) {
|
|
return new Anonymous(n.unit);
|
|
}
|
|
};
|
|
|
|
var Functions = (function (environment) {
|
|
var functions = {
|
|
functionRegistry,
|
|
functionCaller
|
|
}; // register functions
|
|
|
|
functionRegistry.addMultiple(boolean$1);
|
|
functionRegistry.add('default', defaultFunc.eval.bind(defaultFunc));
|
|
functionRegistry.addMultiple(color);
|
|
functionRegistry.addMultiple(colorBlend);
|
|
functionRegistry.addMultiple(dataUri(environment));
|
|
functionRegistry.addMultiple(list);
|
|
functionRegistry.addMultiple(mathFunctions);
|
|
functionRegistry.addMultiple(number$1);
|
|
functionRegistry.addMultiple(string);
|
|
functionRegistry.addMultiple(svg());
|
|
functionRegistry.addMultiple(types);
|
|
return functions;
|
|
});
|
|
|
|
var sourceMapOutput = (function (environment) {
|
|
var SourceMapOutput =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function SourceMapOutput(options) {
|
|
_classCallCheck(this, SourceMapOutput);
|
|
|
|
this._css = [];
|
|
this._rootNode = options.rootNode;
|
|
this._contentsMap = options.contentsMap;
|
|
this._contentsIgnoredCharsMap = options.contentsIgnoredCharsMap;
|
|
|
|
if (options.sourceMapFilename) {
|
|
this._sourceMapFilename = options.sourceMapFilename.replace(/\\/g, '/');
|
|
}
|
|
|
|
this._outputFilename = options.outputFilename;
|
|
this.sourceMapURL = options.sourceMapURL;
|
|
|
|
if (options.sourceMapBasepath) {
|
|
this._sourceMapBasepath = options.sourceMapBasepath.replace(/\\/g, '/');
|
|
}
|
|
|
|
if (options.sourceMapRootpath) {
|
|
this._sourceMapRootpath = options.sourceMapRootpath.replace(/\\/g, '/');
|
|
|
|
if (this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/') {
|
|
this._sourceMapRootpath += '/';
|
|
}
|
|
} else {
|
|
this._sourceMapRootpath = '';
|
|
}
|
|
|
|
this._outputSourceFiles = options.outputSourceFiles;
|
|
this._sourceMapGeneratorConstructor = environment.getSourceMapGenerator();
|
|
this._lineNumber = 0;
|
|
this._column = 0;
|
|
}
|
|
|
|
_createClass(SourceMapOutput, [{
|
|
key: "removeBasepath",
|
|
value: function removeBasepath(path) {
|
|
if (this._sourceMapBasepath && path.indexOf(this._sourceMapBasepath) === 0) {
|
|
path = path.substring(this._sourceMapBasepath.length);
|
|
|
|
if (path.charAt(0) === '\\' || path.charAt(0) === '/') {
|
|
path = path.substring(1);
|
|
}
|
|
}
|
|
|
|
return path;
|
|
}
|
|
}, {
|
|
key: "normalizeFilename",
|
|
value: function normalizeFilename(filename) {
|
|
filename = filename.replace(/\\/g, '/');
|
|
filename = this.removeBasepath(filename);
|
|
return (this._sourceMapRootpath || '') + filename;
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add(chunk, fileInfo, index, mapLines) {
|
|
// ignore adding empty strings
|
|
if (!chunk) {
|
|
return;
|
|
}
|
|
|
|
var lines;
|
|
var sourceLines;
|
|
var columns;
|
|
var sourceColumns;
|
|
var i;
|
|
|
|
if (fileInfo && fileInfo.filename) {
|
|
var inputSource = this._contentsMap[fileInfo.filename]; // remove vars/banner added to the top of the file
|
|
|
|
if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
|
|
// adjust the index
|
|
index -= this._contentsIgnoredCharsMap[fileInfo.filename];
|
|
|
|
if (index < 0) {
|
|
index = 0;
|
|
} // adjust the source
|
|
|
|
|
|
inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
|
|
} // ignore empty content
|
|
|
|
|
|
if (inputSource === undefined) {
|
|
return;
|
|
}
|
|
|
|
inputSource = inputSource.substring(0, index);
|
|
sourceLines = inputSource.split('\n');
|
|
sourceColumns = sourceLines[sourceLines.length - 1];
|
|
}
|
|
|
|
lines = chunk.split('\n');
|
|
columns = lines[lines.length - 1];
|
|
|
|
if (fileInfo && fileInfo.filename) {
|
|
if (!mapLines) {
|
|
this._sourceMapGenerator.addMapping({
|
|
generated: {
|
|
line: this._lineNumber + 1,
|
|
column: this._column
|
|
},
|
|
original: {
|
|
line: sourceLines.length,
|
|
column: sourceColumns.length
|
|
},
|
|
source: this.normalizeFilename(fileInfo.filename)
|
|
});
|
|
} else {
|
|
for (i = 0; i < lines.length; i++) {
|
|
this._sourceMapGenerator.addMapping({
|
|
generated: {
|
|
line: this._lineNumber + i + 1,
|
|
column: i === 0 ? this._column : 0
|
|
},
|
|
original: {
|
|
line: sourceLines.length + i,
|
|
column: i === 0 ? sourceColumns.length : 0
|
|
},
|
|
source: this.normalizeFilename(fileInfo.filename)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lines.length === 1) {
|
|
this._column += columns.length;
|
|
} else {
|
|
this._lineNumber += lines.length - 1;
|
|
this._column = columns.length;
|
|
}
|
|
|
|
this._css.push(chunk);
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty() {
|
|
return this._css.length === 0;
|
|
}
|
|
}, {
|
|
key: "toCSS",
|
|
value: function toCSS(context) {
|
|
this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({
|
|
file: this._outputFilename,
|
|
sourceRoot: null
|
|
});
|
|
|
|
if (this._outputSourceFiles) {
|
|
for (var filename in this._contentsMap) {
|
|
if (this._contentsMap.hasOwnProperty(filename)) {
|
|
var source = this._contentsMap[filename];
|
|
|
|
if (this._contentsIgnoredCharsMap[filename]) {
|
|
source = source.slice(this._contentsIgnoredCharsMap[filename]);
|
|
}
|
|
|
|
this._sourceMapGenerator.setSourceContent(this.normalizeFilename(filename), source);
|
|
}
|
|
}
|
|
}
|
|
|
|
this._rootNode.genCSS(context, this);
|
|
|
|
if (this._css.length > 0) {
|
|
var sourceMapURL;
|
|
var sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
|
|
|
|
if (this.sourceMapURL) {
|
|
sourceMapURL = this.sourceMapURL;
|
|
} else if (this._sourceMapFilename) {
|
|
sourceMapURL = this._sourceMapFilename;
|
|
}
|
|
|
|
this.sourceMapURL = sourceMapURL;
|
|
this.sourceMap = sourceMapContent;
|
|
}
|
|
|
|
return this._css.join('');
|
|
}
|
|
}]);
|
|
|
|
return SourceMapOutput;
|
|
}();
|
|
|
|
return SourceMapOutput;
|
|
});
|
|
|
|
var sourceMapBuilder = (function (SourceMapOutput, environment) {
|
|
var SourceMapBuilder =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function SourceMapBuilder(options) {
|
|
_classCallCheck(this, SourceMapBuilder);
|
|
|
|
this.options = options;
|
|
}
|
|
|
|
_createClass(SourceMapBuilder, [{
|
|
key: "toCSS",
|
|
value: function toCSS(rootNode, options, imports) {
|
|
var sourceMapOutput = new SourceMapOutput({
|
|
contentsIgnoredCharsMap: imports.contentsIgnoredChars,
|
|
rootNode,
|
|
contentsMap: imports.contents,
|
|
sourceMapFilename: this.options.sourceMapFilename,
|
|
sourceMapURL: this.options.sourceMapURL,
|
|
outputFilename: this.options.sourceMapOutputFilename,
|
|
sourceMapBasepath: this.options.sourceMapBasepath,
|
|
sourceMapRootpath: this.options.sourceMapRootpath,
|
|
outputSourceFiles: this.options.outputSourceFiles,
|
|
sourceMapGenerator: this.options.sourceMapGenerator,
|
|
sourceMapFileInline: this.options.sourceMapFileInline
|
|
});
|
|
var css = sourceMapOutput.toCSS(options);
|
|
this.sourceMap = sourceMapOutput.sourceMap;
|
|
this.sourceMapURL = sourceMapOutput.sourceMapURL;
|
|
|
|
if (this.options.sourceMapInputFilename) {
|
|
this.sourceMapInputFilename = sourceMapOutput.normalizeFilename(this.options.sourceMapInputFilename);
|
|
}
|
|
|
|
if (this.options.sourceMapBasepath !== undefined && this.sourceMapURL !== undefined) {
|
|
this.sourceMapURL = sourceMapOutput.removeBasepath(this.sourceMapURL);
|
|
}
|
|
|
|
return css + this.getCSSAppendage();
|
|
}
|
|
}, {
|
|
key: "getCSSAppendage",
|
|
value: function getCSSAppendage() {
|
|
var sourceMapURL = this.sourceMapURL;
|
|
|
|
if (this.options.sourceMapFileInline) {
|
|
if (this.sourceMap === undefined) {
|
|
return '';
|
|
}
|
|
|
|
sourceMapURL = `data:application/json;base64,${environment.encodeBase64(this.sourceMap)}`;
|
|
}
|
|
|
|
if (sourceMapURL) {
|
|
return `/*# sourceMappingURL=${sourceMapURL} */`;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}, {
|
|
key: "getExternalSourceMap",
|
|
value: function getExternalSourceMap() {
|
|
return this.sourceMap;
|
|
}
|
|
}, {
|
|
key: "setExternalSourceMap",
|
|
value: function setExternalSourceMap(sourceMap) {
|
|
this.sourceMap = sourceMap;
|
|
}
|
|
}, {
|
|
key: "isInline",
|
|
value: function isInline() {
|
|
return this.options.sourceMapFileInline;
|
|
}
|
|
}, {
|
|
key: "getSourceMapURL",
|
|
value: function getSourceMapURL() {
|
|
return this.sourceMapURL;
|
|
}
|
|
}, {
|
|
key: "getOutputFilename",
|
|
value: function getOutputFilename() {
|
|
return this.options.sourceMapOutputFilename;
|
|
}
|
|
}, {
|
|
key: "getInputFilename",
|
|
value: function getInputFilename() {
|
|
return this.sourceMapInputFilename;
|
|
}
|
|
}]);
|
|
|
|
return SourceMapBuilder;
|
|
}();
|
|
|
|
return SourceMapBuilder;
|
|
});
|
|
|
|
var transformTree = (function (root) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var evaldRoot;
|
|
var variables = options.variables;
|
|
var evalEnv = new contexts.Eval(options); //
|
|
// Allows setting variables with a hash, so:
|
|
//
|
|
// `{ color: new tree.Color('#f01') }` will become:
|
|
//
|
|
// new tree.Declaration('@color',
|
|
// new tree.Value([
|
|
// new tree.Expression([
|
|
// new tree.Color('#f01')
|
|
// ])
|
|
// ])
|
|
// )
|
|
//
|
|
|
|
if (typeof variables === 'object' && !Array.isArray(variables)) {
|
|
variables = Object.keys(variables).map(function (k) {
|
|
var value = variables[k];
|
|
|
|
if (!(value instanceof tree.Value)) {
|
|
if (!(value instanceof tree.Expression)) {
|
|
value = new tree.Expression([value]);
|
|
}
|
|
|
|
value = new tree.Value([value]);
|
|
}
|
|
|
|
return new tree.Declaration(`@${k}`, value, false, null, 0);
|
|
});
|
|
evalEnv.frames = [new tree.Ruleset(null, variables)];
|
|
}
|
|
|
|
var visitors$1 = [new visitors.JoinSelectorVisitor(), new visitors.MarkVisibleSelectorsVisitor(true), new visitors.ExtendVisitor(), new visitors.ToCSSVisitor({
|
|
compress: Boolean(options.compress)
|
|
})];
|
|
var preEvalVisitors = [];
|
|
var v;
|
|
var visitorIterator;
|
|
/**
|
|
* first() / get() allows visitors to be added while visiting
|
|
*
|
|
* @todo Add scoping for visitors just like functions for @plugin; right now they're global
|
|
*/
|
|
|
|
if (options.pluginManager) {
|
|
visitorIterator = options.pluginManager.visitor();
|
|
|
|
for (var i = 0; i < 2; i++) {
|
|
visitorIterator.first();
|
|
|
|
while (v = visitorIterator.get()) {
|
|
if (v.isPreEvalVisitor) {
|
|
if (i === 0 || preEvalVisitors.indexOf(v) === -1) {
|
|
preEvalVisitors.push(v);
|
|
v.run(root);
|
|
}
|
|
} else {
|
|
if (i === 0 || visitors$1.indexOf(v) === -1) {
|
|
if (v.isPreVisitor) {
|
|
visitors$1.unshift(v);
|
|
} else {
|
|
visitors$1.push(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
evaldRoot = root.eval(evalEnv);
|
|
|
|
for (var i = 0; i < visitors$1.length; i++) {
|
|
visitors$1[i].run(evaldRoot);
|
|
} // Run any remaining visitors added after eval pass
|
|
|
|
|
|
if (options.pluginManager) {
|
|
visitorIterator.first();
|
|
|
|
while (v = visitorIterator.get()) {
|
|
if (visitors$1.indexOf(v) === -1 && preEvalVisitors.indexOf(v) === -1) {
|
|
v.run(evaldRoot);
|
|
}
|
|
}
|
|
}
|
|
|
|
return evaldRoot;
|
|
});
|
|
|
|
var parseTree = (function (SourceMapBuilder) {
|
|
var ParseTree =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ParseTree(root, imports) {
|
|
_classCallCheck(this, ParseTree);
|
|
|
|
this.root = root;
|
|
this.imports = imports;
|
|
}
|
|
|
|
_createClass(ParseTree, [{
|
|
key: "toCSS",
|
|
value: function toCSS(options) {
|
|
var evaldRoot;
|
|
var result = {};
|
|
var sourceMapBuilder;
|
|
|
|
try {
|
|
evaldRoot = transformTree(this.root, options);
|
|
} catch (e) {
|
|
throw new LessError(e, this.imports);
|
|
}
|
|
|
|
try {
|
|
var compress = Boolean(options.compress);
|
|
|
|
if (compress) {
|
|
logger.warn('The compress option has been deprecated. ' + 'We recommend you use a dedicated css minifier, for instance see less-plugin-clean-css.');
|
|
}
|
|
|
|
var toCSSOptions = {
|
|
compress,
|
|
dumpLineNumbers: options.dumpLineNumbers,
|
|
strictUnits: Boolean(options.strictUnits),
|
|
numPrecision: 8
|
|
};
|
|
|
|
if (options.sourceMap) {
|
|
sourceMapBuilder = new SourceMapBuilder(options.sourceMap);
|
|
result.css = sourceMapBuilder.toCSS(evaldRoot, toCSSOptions, this.imports);
|
|
} else {
|
|
result.css = evaldRoot.toCSS(toCSSOptions);
|
|
}
|
|
} catch (e) {
|
|
throw new LessError(e, this.imports);
|
|
}
|
|
|
|
if (options.pluginManager) {
|
|
var postProcessors = options.pluginManager.getPostProcessors();
|
|
|
|
for (var i = 0; i < postProcessors.length; i++) {
|
|
result.css = postProcessors[i].process(result.css, {
|
|
sourceMap: sourceMapBuilder,
|
|
options,
|
|
imports: this.imports
|
|
});
|
|
}
|
|
}
|
|
|
|
if (options.sourceMap) {
|
|
result.map = sourceMapBuilder.getExternalSourceMap();
|
|
}
|
|
|
|
result.imports = [];
|
|
|
|
for (var file in this.imports.files) {
|
|
if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
|
|
result.imports.push(file);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return ParseTree;
|
|
}();
|
|
|
|
return ParseTree;
|
|
});
|
|
|
|
var importManager = (function (environment) {
|
|
// FileInfo = {
|
|
// 'rewriteUrls' - option - whether to adjust URL's to be relative
|
|
// 'filename' - full resolved filename of current file
|
|
// 'rootpath' - path to append to normal URLs for this node
|
|
// 'currentDirectory' - path to the current file, absolute
|
|
// 'rootFilename' - filename of the base file
|
|
// 'entryPath' - absolute path to the entry file
|
|
// 'reference' - whether the file should not be output and only output parts that are referenced
|
|
var ImportManager =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ImportManager(less, context, rootFileInfo) {
|
|
_classCallCheck(this, ImportManager);
|
|
|
|
this.less = less;
|
|
this.rootFilename = rootFileInfo.filename;
|
|
this.paths = context.paths || []; // Search paths, when importing
|
|
|
|
this.contents = {}; // map - filename to contents of all the files
|
|
|
|
this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
|
|
|
|
this.mime = context.mime;
|
|
this.error = null;
|
|
this.context = context; // Deprecated? Unused outside of here, could be useful.
|
|
|
|
this.queue = []; // Files which haven't been imported yet
|
|
|
|
this.files = {}; // Holds the imported parse trees.
|
|
}
|
|
/**
|
|
* Add an import to be imported
|
|
* @param path - the raw path
|
|
* @param tryAppendExtension - whether to try appending a file extension (.less or .js if the path has no extension)
|
|
* @param currentFileInfo - the current file info (used for instance to work out relative paths)
|
|
* @param importOptions - import options
|
|
* @param callback - callback for when it is imported
|
|
*/
|
|
|
|
|
|
_createClass(ImportManager, [{
|
|
key: "push",
|
|
value: function push(path, tryAppendExtension, currentFileInfo, importOptions, callback) {
|
|
var importManager = this;
|
|
var pluginLoader = this.context.pluginManager.Loader;
|
|
this.queue.push(path);
|
|
|
|
var fileParsedFunc = function fileParsedFunc(e, root, fullPath) {
|
|
importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
|
|
|
|
var importedEqualsRoot = fullPath === importManager.rootFilename;
|
|
|
|
if (importOptions.optional && e) {
|
|
callback(null, {
|
|
rules: []
|
|
}, false, null);
|
|
logger.info(`The file ${fullPath} was skipped because it was not found and the import was marked optional.`);
|
|
} else {
|
|
// Inline imports aren't cached here.
|
|
// If we start to cache them, please make sure they won't conflict with non-inline imports of the
|
|
// same name as they used to do before this comment and the condition below have been added.
|
|
if (!importManager.files[fullPath] && !importOptions.inline) {
|
|
importManager.files[fullPath] = {
|
|
root,
|
|
options: importOptions
|
|
};
|
|
}
|
|
|
|
if (e && !importManager.error) {
|
|
importManager.error = e;
|
|
}
|
|
|
|
callback(e, root, importedEqualsRoot, fullPath);
|
|
}
|
|
};
|
|
|
|
var newFileInfo = {
|
|
rewriteUrls: this.context.rewriteUrls,
|
|
entryPath: currentFileInfo.entryPath,
|
|
rootpath: currentFileInfo.rootpath,
|
|
rootFilename: currentFileInfo.rootFilename
|
|
};
|
|
var fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
|
|
|
|
if (!fileManager) {
|
|
fileParsedFunc({
|
|
message: `Could not find a file-manager for ${path}`
|
|
});
|
|
return;
|
|
}
|
|
|
|
var loadFileCallback = function loadFileCallback(loadedFile) {
|
|
var plugin;
|
|
var resolvedFilename = loadedFile.filename;
|
|
var contents = loadedFile.contents.replace(/^\uFEFF/, ''); // Pass on an updated rootpath if path of imported file is relative and file
|
|
// is in a (sub|sup) directory
|
|
//
|
|
// Examples:
|
|
// - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
|
|
// then rootpath should become 'less/module/nav/'
|
|
// - If path of imported file is '../mixins.less' and rootpath is 'less/',
|
|
// then rootpath should become 'less/../'
|
|
|
|
newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
|
|
|
|
if (newFileInfo.rewriteUrls) {
|
|
newFileInfo.rootpath = fileManager.join(importManager.context.rootpath || '', fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
|
|
|
|
if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
|
|
newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
|
|
}
|
|
}
|
|
|
|
newFileInfo.filename = resolvedFilename;
|
|
var newEnv = new contexts.Parse(importManager.context);
|
|
newEnv.processImports = false;
|
|
importManager.contents[resolvedFilename] = contents;
|
|
|
|
if (currentFileInfo.reference || importOptions.reference) {
|
|
newFileInfo.reference = true;
|
|
}
|
|
|
|
if (importOptions.isPlugin) {
|
|
plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
|
|
|
|
if (plugin instanceof LessError) {
|
|
fileParsedFunc(plugin, null, resolvedFilename);
|
|
} else {
|
|
fileParsedFunc(null, plugin, resolvedFilename);
|
|
}
|
|
} else if (importOptions.inline) {
|
|
fileParsedFunc(null, contents, resolvedFilename);
|
|
} else {
|
|
// import (multiple) parse trees apparently get altered and can't be cached.
|
|
// TODO: investigate why this is
|
|
if (importManager.files[resolvedFilename] && !importManager.files[resolvedFilename].options.multiple && !importOptions.multiple) {
|
|
fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
|
|
} else {
|
|
new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
|
|
fileParsedFunc(e, root, resolvedFilename);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
var promise;
|
|
var context = clone(this.context);
|
|
|
|
if (tryAppendExtension) {
|
|
context.ext = importOptions.isPlugin ? '.js' : '.less';
|
|
}
|
|
|
|
if (importOptions.isPlugin) {
|
|
context.mime = 'application/javascript';
|
|
promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
|
|
} else {
|
|
promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment, function (err, loadedFile) {
|
|
if (err) {
|
|
fileParsedFunc(err);
|
|
} else {
|
|
loadFileCallback(loadedFile);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (promise) {
|
|
promise.then(loadFileCallback, fileParsedFunc);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return ImportManager;
|
|
}();
|
|
|
|
return ImportManager;
|
|
});
|
|
|
|
var Render = (function (environment, ParseTree, ImportManager) {
|
|
var render = function render(input, options, callback) {
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = copyOptions(this.options, {});
|
|
} else {
|
|
options = copyOptions(this.options, options || {});
|
|
}
|
|
|
|
if (!callback) {
|
|
var self = this;
|
|
return new Promise(function (resolve, reject) {
|
|
render.call(self, input, options, function (err, output) {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(output);
|
|
}
|
|
});
|
|
});
|
|
} else {
|
|
this.parse(input, options, function (err, root, imports, options) {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
|
|
var result;
|
|
|
|
try {
|
|
var parseTree = new ParseTree(root, imports);
|
|
result = parseTree.toCSS(options);
|
|
} catch (err) {
|
|
return callback(err);
|
|
}
|
|
|
|
callback(null, result);
|
|
});
|
|
}
|
|
};
|
|
|
|
return render;
|
|
});
|
|
|
|
/**
|
|
* Plugin Manager
|
|
*/
|
|
var PluginManager =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function PluginManager(less) {
|
|
_classCallCheck(this, PluginManager);
|
|
|
|
this.less = less;
|
|
this.visitors = [];
|
|
this.preProcessors = [];
|
|
this.postProcessors = [];
|
|
this.installedPlugins = [];
|
|
this.fileManagers = [];
|
|
this.iterator = -1;
|
|
this.pluginCache = {};
|
|
this.Loader = new less.PluginLoader(less);
|
|
}
|
|
/**
|
|
* Adds all the plugins in the array
|
|
* @param {Array} plugins
|
|
*/
|
|
|
|
|
|
_createClass(PluginManager, [{
|
|
key: "addPlugins",
|
|
value: function addPlugins(plugins) {
|
|
if (plugins) {
|
|
for (var i = 0; i < plugins.length; i++) {
|
|
this.addPlugin(plugins[i]);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* @param plugin
|
|
* @param {String} filename
|
|
*/
|
|
|
|
}, {
|
|
key: "addPlugin",
|
|
value: function addPlugin(plugin, filename, functionRegistry) {
|
|
this.installedPlugins.push(plugin);
|
|
|
|
if (filename) {
|
|
this.pluginCache[filename] = plugin;
|
|
}
|
|
|
|
if (plugin.install) {
|
|
plugin.install(this.less, this, functionRegistry || this.less.functions.functionRegistry);
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* @param filename
|
|
*/
|
|
|
|
}, {
|
|
key: "get",
|
|
value: function get(filename) {
|
|
return this.pluginCache[filename];
|
|
}
|
|
/**
|
|
* Adds a visitor. The visitor object has options on itself to determine
|
|
* when it should run.
|
|
* @param visitor
|
|
*/
|
|
|
|
}, {
|
|
key: "addVisitor",
|
|
value: function addVisitor(visitor) {
|
|
this.visitors.push(visitor);
|
|
}
|
|
/**
|
|
* Adds a pre processor object
|
|
* @param {object} preProcessor
|
|
* @param {number} priority - guidelines 1 = before import, 1000 = import, 2000 = after import
|
|
*/
|
|
|
|
}, {
|
|
key: "addPreProcessor",
|
|
value: function addPreProcessor(preProcessor, priority) {
|
|
var indexToInsertAt;
|
|
|
|
for (indexToInsertAt = 0; indexToInsertAt < this.preProcessors.length; indexToInsertAt++) {
|
|
if (this.preProcessors[indexToInsertAt].priority >= priority) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.preProcessors.splice(indexToInsertAt, 0, {
|
|
preProcessor,
|
|
priority
|
|
});
|
|
}
|
|
/**
|
|
* Adds a post processor object
|
|
* @param {object} postProcessor
|
|
* @param {number} priority - guidelines 1 = before compression, 1000 = compression, 2000 = after compression
|
|
*/
|
|
|
|
}, {
|
|
key: "addPostProcessor",
|
|
value: function addPostProcessor(postProcessor, priority) {
|
|
var indexToInsertAt;
|
|
|
|
for (indexToInsertAt = 0; indexToInsertAt < this.postProcessors.length; indexToInsertAt++) {
|
|
if (this.postProcessors[indexToInsertAt].priority >= priority) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.postProcessors.splice(indexToInsertAt, 0, {
|
|
postProcessor,
|
|
priority
|
|
});
|
|
}
|
|
/**
|
|
*
|
|
* @param manager
|
|
*/
|
|
|
|
}, {
|
|
key: "addFileManager",
|
|
value: function addFileManager(manager) {
|
|
this.fileManagers.push(manager);
|
|
}
|
|
/**
|
|
*
|
|
* @returns {Array}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "getPreProcessors",
|
|
value: function getPreProcessors() {
|
|
var preProcessors = [];
|
|
|
|
for (var i = 0; i < this.preProcessors.length; i++) {
|
|
preProcessors.push(this.preProcessors[i].preProcessor);
|
|
}
|
|
|
|
return preProcessors;
|
|
}
|
|
/**
|
|
*
|
|
* @returns {Array}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "getPostProcessors",
|
|
value: function getPostProcessors() {
|
|
var postProcessors = [];
|
|
|
|
for (var i = 0; i < this.postProcessors.length; i++) {
|
|
postProcessors.push(this.postProcessors[i].postProcessor);
|
|
}
|
|
|
|
return postProcessors;
|
|
}
|
|
/**
|
|
*
|
|
* @returns {Array}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "getVisitors",
|
|
value: function getVisitors() {
|
|
return this.visitors;
|
|
}
|
|
}, {
|
|
key: "visitor",
|
|
value: function visitor() {
|
|
var self = this;
|
|
return {
|
|
first: function first() {
|
|
self.iterator = -1;
|
|
return self.visitors[self.iterator];
|
|
},
|
|
get: function get() {
|
|
self.iterator += 1;
|
|
return self.visitors[self.iterator];
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
*
|
|
* @returns {Array}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "getFileManagers",
|
|
value: function getFileManagers() {
|
|
return this.fileManagers;
|
|
}
|
|
}]);
|
|
|
|
return PluginManager;
|
|
}();
|
|
|
|
var pm;
|
|
|
|
function PluginManagerFactory(less, newFactory) {
|
|
if (newFactory || !pm) {
|
|
pm = new PluginManager(less);
|
|
}
|
|
|
|
return pm;
|
|
}
|
|
|
|
var Parse = (function (environment, ParseTree, ImportManager) {
|
|
var parse = function parse(input, options, callback) {
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = copyOptions(this.options, {});
|
|
} else {
|
|
options = copyOptions(this.options, options || {});
|
|
}
|
|
|
|
if (!callback) {
|
|
var self = this;
|
|
return new Promise(function (resolve, reject) {
|
|
parse.call(self, input, options, function (err, output) {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(output);
|
|
}
|
|
});
|
|
});
|
|
} else {
|
|
var context;
|
|
var rootFileInfo;
|
|
var pluginManager = new PluginManagerFactory(this, !options.reUsePluginManager);
|
|
options.pluginManager = pluginManager;
|
|
context = new contexts.Parse(options);
|
|
|
|
if (options.rootFileInfo) {
|
|
rootFileInfo = options.rootFileInfo;
|
|
} else {
|
|
var filename = options.filename || 'input';
|
|
var entryPath = filename.replace(/[^\/\\]*$/, '');
|
|
rootFileInfo = {
|
|
filename,
|
|
rewriteUrls: context.rewriteUrls,
|
|
rootpath: context.rootpath || '',
|
|
currentDirectory: entryPath,
|
|
entryPath,
|
|
rootFilename: filename
|
|
}; // add in a missing trailing slash
|
|
|
|
if (rootFileInfo.rootpath && rootFileInfo.rootpath.slice(-1) !== '/') {
|
|
rootFileInfo.rootpath += '/';
|
|
}
|
|
}
|
|
|
|
var imports = new ImportManager(this, context, rootFileInfo);
|
|
this.importManager = imports; // TODO: allow the plugins to be just a list of paths or names
|
|
// Do an async plugin queue like lessc
|
|
|
|
if (options.plugins) {
|
|
options.plugins.forEach(function (plugin) {
|
|
var evalResult;
|
|
var contents;
|
|
|
|
if (plugin.fileContent) {
|
|
contents = plugin.fileContent.replace(/^\uFEFF/, '');
|
|
evalResult = pluginManager.Loader.evalPlugin(contents, context, imports, plugin.options, plugin.filename);
|
|
|
|
if (evalResult instanceof LessError) {
|
|
return callback(evalResult);
|
|
}
|
|
} else {
|
|
pluginManager.addPlugin(plugin);
|
|
}
|
|
});
|
|
}
|
|
|
|
new Parser(context, imports, rootFileInfo).parse(input, function (e, root) {
|
|
if (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
callback(null, root, imports, options);
|
|
}, options);
|
|
}
|
|
};
|
|
|
|
return parse;
|
|
});
|
|
|
|
var createFromEnvironment = (function (environment, fileManagers) {
|
|
/**
|
|
* @todo
|
|
* This original code could be improved quite a bit.
|
|
* Many classes / modules currently add side-effects / mutations to passed in objects,
|
|
* which makes it hard to refactor and reason about.
|
|
*/
|
|
environment = new environment$1(environment, fileManagers);
|
|
var SourceMapOutput = sourceMapOutput(environment);
|
|
var SourceMapBuilder = sourceMapBuilder(SourceMapOutput, environment);
|
|
var ParseTree = parseTree(SourceMapBuilder);
|
|
var ImportManager = importManager(environment);
|
|
var render = Render(environment, ParseTree);
|
|
var parse = Parse(environment, ParseTree, ImportManager);
|
|
var functions = Functions(environment);
|
|
/**
|
|
* @todo
|
|
* This root properties / methods need to be organized.
|
|
* It's not clear what should / must be public and why.
|
|
*/
|
|
|
|
var initial = {
|
|
version: [3, 10, 3],
|
|
data,
|
|
tree,
|
|
Environment: environment$1,
|
|
AbstractFileManager,
|
|
AbstractPluginLoader,
|
|
environment,
|
|
visitors,
|
|
Parser,
|
|
functions,
|
|
contexts,
|
|
SourceMapOutput,
|
|
SourceMapBuilder,
|
|
ParseTree,
|
|
ImportManager,
|
|
render,
|
|
parse,
|
|
LessError,
|
|
transformTree,
|
|
utils,
|
|
PluginManager: PluginManagerFactory,
|
|
logger
|
|
}; // Create a public API
|
|
|
|
var ctor = function ctor(t) {
|
|
return function () {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _construct(t, args);
|
|
};
|
|
};
|
|
|
|
var t;
|
|
var api = Object.create(initial);
|
|
|
|
for (var n in initial.tree) {
|
|
/* eslint guard-for-in: 0 */
|
|
t = initial.tree[n];
|
|
|
|
if (typeof t === 'function') {
|
|
api[n.toLowerCase()] = ctor(t);
|
|
} else {
|
|
api[n] = Object.create(null);
|
|
|
|
for (var o in t) {
|
|
/* eslint guard-for-in: 0 */
|
|
api[n][o.toLowerCase()] = ctor(t[o]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return api;
|
|
});
|
|
|
|
function createCommonjsModule(fn, module) {
|
|
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
|
}
|
|
|
|
var lesscHelper = createCommonjsModule(function (module, exports) {
|
|
// lessc_helper.js
|
|
//
|
|
// helper functions for lessc
|
|
var lessc_helper = {
|
|
// Stylize a string
|
|
stylize: function stylize(str, style) {
|
|
var styles = {
|
|
'reset': [0, 0],
|
|
'bold': [1, 22],
|
|
'inverse': [7, 27],
|
|
'underline': [4, 24],
|
|
'yellow': [33, 39],
|
|
'green': [32, 39],
|
|
'red': [31, 39],
|
|
'grey': [90, 39]
|
|
};
|
|
return `\x1b[${styles[style][0]}m${str}\x1b[${styles[style][1]}m`;
|
|
},
|
|
// Print command line options
|
|
printUsage: function printUsage() {
|
|
console.log('usage: lessc [option option=parameter ...] <source> [destination]');
|
|
console.log('');
|
|
console.log('If source is set to `-\' (dash or hyphen-minus), input is read from stdin.');
|
|
console.log('');
|
|
console.log('options:');
|
|
console.log(' -h, --help Prints help (this message) and exit.');
|
|
console.log(' --include-path=PATHS Sets include paths. Separated by `:\'. `;\' also supported on windows.');
|
|
console.log(' -M, --depends Outputs a makefile import dependency list to stdout.');
|
|
console.log(' --no-color Disables colorized output.');
|
|
console.log(' --ie-compat Enables IE8 compatibility checks.');
|
|
console.log(' --js Enables inline JavaScript in less files');
|
|
console.log(' -l, --lint Syntax check only (lint).');
|
|
console.log(' -s, --silent Suppresses output of error messages.');
|
|
console.log(' --strict-imports Forces evaluation of imports.');
|
|
console.log(' --insecure Allows imports from insecure https hosts.');
|
|
console.log(' -v, --version Prints version number and exit.');
|
|
console.log(' --verbose Be verbose.');
|
|
console.log(' --source-map[=FILENAME] Outputs a v3 sourcemap to the filename (or output filename.map).');
|
|
console.log(' --source-map-rootpath=X Adds this path onto the sourcemap filename and less file paths.');
|
|
console.log(' --source-map-basepath=X Sets sourcemap base path, defaults to current working directory.');
|
|
console.log(' --source-map-include-source Puts the less files into the map instead of referencing them.');
|
|
console.log(' --source-map-inline Puts the map (and any less files) as a base64 data uri into the output css file.');
|
|
console.log(' --source-map-url=URL Sets a custom URL to map file, for sourceMappingURL comment');
|
|
console.log(' in generated CSS file.');
|
|
console.log(' -rp, --rootpath=URL Sets rootpath for url rewriting in relative imports and urls');
|
|
console.log(' Works with or without the relative-urls option.');
|
|
console.log(' -ru=, --rewrite-urls= Rewrites URLs to make them relative to the base less file.');
|
|
console.log(' all|local|off \'all\' rewrites all URLs, \'local\' just those starting with a \'.\'');
|
|
console.log('');
|
|
console.log(' -m=, --math=');
|
|
console.log(' always Less will eagerly perform math operations always.');
|
|
console.log(' parens-division Math performed except for division (/) operator');
|
|
console.log(' parens | strict Math only performed inside parentheses');
|
|
console.log(' strict-legacy Parens required in very strict terms (legacy --strict-math)');
|
|
console.log('');
|
|
console.log(' -su=on|off Allows mixed units, e.g. 1px+1em or 1px*1px which have units');
|
|
console.log(' --strict-units=on|off that cannot be represented.');
|
|
console.log(' --global-var=\'VAR=VALUE\' Defines a variable that can be referenced by the file.');
|
|
console.log(' --modify-var=\'VAR=VALUE\' Modifies a variable already declared in the file.');
|
|
console.log(' --url-args=\'QUERYSTRING\' Adds params into url tokens (e.g. 42, cb=42 or \'a=1&b=2\')');
|
|
console.log(' --plugin=PLUGIN=OPTIONS Loads a plugin. You can also omit the --plugin= if the plugin begins');
|
|
console.log(' less-plugin. E.g. the clean css plugin is called less-plugin-clean-css');
|
|
console.log(' once installed (npm install less-plugin-clean-css), use either with');
|
|
console.log(' --plugin=less-plugin-clean-css or just --clean-css');
|
|
console.log(' specify options afterwards e.g. --plugin=less-plugin-clean-css="advanced"');
|
|
console.log(' or --clean-css="advanced"');
|
|
console.log('');
|
|
console.log('-------------------------- Deprecated ----------------');
|
|
console.log(' -sm=on|off Legacy parens-only math. Use --math');
|
|
console.log(' --strict-math=on|off ');
|
|
console.log('');
|
|
console.log(' --line-numbers=TYPE Outputs filename and line numbers.');
|
|
console.log(' TYPE can be either \'comments\', which will output');
|
|
console.log(' the debug info within comments, \'mediaquery\'');
|
|
console.log(' that will output the information within a fake');
|
|
console.log(' media query which is compatible with the SASS');
|
|
console.log(' format, and \'all\' which will do both.');
|
|
console.log(' -x, --compress Compresses output by removing some whitespaces.');
|
|
console.log(' We recommend you use a dedicated minifer like less-plugin-clean-css');
|
|
console.log('');
|
|
console.log('Report bugs to: http://github.com/less/less.js/issues');
|
|
console.log('Home page: <http://lesscss.org/>');
|
|
}
|
|
}; // Exports helper functions
|
|
|
|
for (var h in lessc_helper) {
|
|
if (lessc_helper.hasOwnProperty(h)) {
|
|
exports[h] = lessc_helper[h];
|
|
}
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Node Plugin Loader
|
|
*/
|
|
|
|
var PluginLoader =
|
|
/*#__PURE__*/
|
|
function (_AbstractPluginLoader) {
|
|
_inherits(PluginLoader, _AbstractPluginLoader);
|
|
|
|
function PluginLoader(less) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PluginLoader);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(PluginLoader).call(this));
|
|
_this.less = less;
|
|
|
|
_this.require = function (prefix) {
|
|
prefix = path.dirname(prefix);
|
|
return function (id) {
|
|
var str = id.substr(0, 2);
|
|
|
|
if (str === '..' || str === './') {
|
|
return require(path.join(prefix, id));
|
|
} else {
|
|
return require(id);
|
|
}
|
|
};
|
|
};
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PluginLoader, [{
|
|
key: "loadPlugin",
|
|
value: function loadPlugin(filename, basePath, context, environment, fileManager) {
|
|
var prefix = filename.slice(0, 1);
|
|
var explicit = prefix === '.' || prefix === '/' || filename.slice(-3).toLowerCase() === '.js';
|
|
|
|
if (!explicit) {
|
|
context.prefixes = ['less-plugin-', ''];
|
|
}
|
|
|
|
return new Promise(function (fulfill, reject) {
|
|
fileManager.loadFile(filename, basePath, context, environment).then(function (data) {
|
|
try {
|
|
fulfill(data);
|
|
} catch (e) {
|
|
console.log(e);
|
|
reject(e);
|
|
}
|
|
}).catch(function (err) {
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return PluginLoader;
|
|
}(AbstractPluginLoader);
|
|
|
|
// Export a new default each time
|
|
var defaultOptions = (function () {
|
|
return {
|
|
/* Inline Javascript - @plugin still allowed */
|
|
javascriptEnabled: false,
|
|
|
|
/* Outputs a makefile import dependency list to stdout. */
|
|
depends: false,
|
|
|
|
/* (DEPRECATED) Compress using less built-in compression.
|
|
* This does an okay job but does not utilise all the tricks of
|
|
* dedicated css compression. */
|
|
compress: false,
|
|
|
|
/* Runs the less parser and just reports errors without any output. */
|
|
lint: false,
|
|
|
|
/* Sets available include paths.
|
|
* If the file in an @import rule does not exist at that exact location,
|
|
* less will look for it at the location(s) passed to this option.
|
|
* You might use this for instance to specify a path to a library which
|
|
* you want to be referenced simply and relatively in the less files. */
|
|
paths: [],
|
|
|
|
/* color output in the terminal */
|
|
color: true,
|
|
|
|
/* The strictImports controls whether the compiler will allow an @import inside of either
|
|
* @media blocks or (a later addition) other selector blocks.
|
|
* See: https://github.com/less/less.js/issues/656 */
|
|
strictImports: false,
|
|
|
|
/* Allow Imports from Insecure HTTPS Hosts */
|
|
insecure: false,
|
|
|
|
/* Allows you to add a path to every generated import and url in your css.
|
|
* This does not affect less import statements that are processed, just ones
|
|
* that are left in the output css. */
|
|
rootpath: '',
|
|
|
|
/* By default URLs are kept as-is, so if you import a file in a sub-directory
|
|
* that references an image, exactly the same URL will be output in the css.
|
|
* This option allows you to re-write URL's in imported files so that the
|
|
* URL is always relative to the base imported file */
|
|
rewriteUrls: false,
|
|
|
|
/* How to process math
|
|
* 0 always - eagerly try to solve all operations
|
|
* 1 parens-division - require parens for division "/"
|
|
* 2 parens | strict - require parens for all operations
|
|
* 3 strict-legacy - legacy strict behavior (super-strict)
|
|
*/
|
|
math: 0,
|
|
|
|
/* Without this option, less attempts to guess at the output unit when it does maths. */
|
|
strictUnits: false,
|
|
|
|
/* Effectively the declaration is put at the top of your base Less file,
|
|
* meaning it can be used but it also can be overridden if this variable
|
|
* is defined in the file. */
|
|
globalVars: null,
|
|
|
|
/* As opposed to the global variable option, this puts the declaration at the
|
|
* end of your base file, meaning it will override anything defined in your Less file. */
|
|
modifyVars: null,
|
|
|
|
/* This option allows you to specify a argument to go on to every URL. */
|
|
urlArgs: ''
|
|
};
|
|
});
|
|
|
|
var imageSize = (function (environment) {
|
|
function _imageSize(functionContext, filePathNode) {
|
|
var filePath = filePathNode.value;
|
|
var currentFileInfo = functionContext.currentFileInfo;
|
|
var currentDirectory = currentFileInfo.rewriteUrls ? currentFileInfo.currentDirectory : currentFileInfo.entryPath;
|
|
var fragmentStart = filePath.indexOf('#');
|
|
var fragment = '';
|
|
|
|
if (fragmentStart !== -1) {
|
|
fragment = filePath.slice(fragmentStart);
|
|
filePath = filePath.slice(0, fragmentStart);
|
|
}
|
|
|
|
var fileManager = environment.getFileManager(filePath, currentDirectory, functionContext.context, environment, true);
|
|
|
|
if (!fileManager) {
|
|
throw {
|
|
type: 'File',
|
|
message: `Can not set up FileManager for ${filePathNode}`
|
|
};
|
|
}
|
|
|
|
var fileSync = fileManager.loadFileSync(filePath, currentDirectory, functionContext.context, environment);
|
|
|
|
if (fileSync.error) {
|
|
throw fileSync.error;
|
|
}
|
|
|
|
var sizeOf = require('image-size');
|
|
|
|
return sizeOf(fileSync.filename);
|
|
}
|
|
|
|
var imageFunctions = {
|
|
'image-size': function imageSize(filePathNode) {
|
|
var size = _imageSize(this, filePathNode);
|
|
|
|
return new Expression([new Dimension(size.width, 'px'), new Dimension(size.height, 'px')]);
|
|
},
|
|
'image-width': function imageWidth(filePathNode) {
|
|
var size = _imageSize(this, filePathNode);
|
|
|
|
return new Dimension(size.width, 'px');
|
|
},
|
|
'image-height': function imageHeight(filePathNode) {
|
|
var size = _imageSize(this, filePathNode);
|
|
|
|
return new Dimension(size.height, 'px');
|
|
}
|
|
};
|
|
functionRegistry.addMultiple(imageFunctions);
|
|
});
|
|
|
|
var less = createFromEnvironment(environment, [new FileManager(), new UrlFileManager()]); // allow people to create less with their own environment
|
|
|
|
less.createFromEnvironment = createFromEnvironment;
|
|
less.lesscHelper = lesscHelper;
|
|
less.PluginLoader = PluginLoader;
|
|
less.fs = fs$1;
|
|
less.FileManager = FileManager;
|
|
less.UrlFileManager = UrlFileManager; // Set up options
|
|
|
|
less.options = defaultOptions(); // provide image-size functionality
|
|
|
|
imageSize(less.environment);
|
|
|
|
module.exports = less;
|