} */ hash, /** @type {Node} */ r) {
if (r instanceof Declaration && r.variable !== true) {
const name = (/** @type {Node[]} */ (r.name).length === 1) && (/** @type {Node[]} */ (r.name)[0] instanceof Keyword) ?
/** @type {string} */ (/** @type {Node[]} */ (r.name)[0].value) : /** @type {string} */ (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;
}
/** @param {string} name */
variable(name) {
const decl = this.variables()[name];
if (decl) {
return this.parseValue(decl);
}
}
/** @param {string} name */
property(name) {
const decl = this.properties()[name];
if (decl) {
return this.parseValue(decl);
}
}
lastDeclaration() {
for (let i = /** @type {Node[]} */ (this.rules).length; i > 0; i--) {
const decl = /** @type {Node[]} */ (this.rules)[i - 1];
if (decl instanceof Declaration) {
return this.parseValue(decl);
}
}
}
/** @param {Declaration | Declaration[]} toParse */
parseValue(toParse) {
const self = this;
/** @param {Declaration} decl */
function transformDeclaration(decl) {
if (decl.value instanceof Anonymous && !/** @type {Declaration & { parsed?: boolean }} */ (decl).parsed) {
if (typeof decl.value.value === 'string') {
new (/** @type {new (...args: [EvalContext, object, FileInfo, number]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(/** @type {{ context: EvalContext, importManager: object }} */ (/** @type {Ruleset} */ (this).parse).context, /** @type {{ context: EvalContext, importManager: object }} */ (/** @type {Ruleset} */ (this).parse).importManager, decl.fileInfo(), decl.value.getIndex()).parseNode(
decl.value.value,
['value', 'important'],
function(/** @type {Error | null} */ err, /** @type {Node[]} */ result) {
if (err) {
decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
}
if (result) {
decl.value = result[0];
/** @type {Declaration & { important?: string }} */ (decl).important = /** @type {string} */ (/** @type {unknown} */ (result[1])) || '';
decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
}
});
} else {
decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
}
return decl;
}
else {
return decl;
}
}
if (!Array.isArray(toParse)) {
return transformDeclaration.call(self, toParse);
}
else {
/** @type {Declaration[]} */
const nodes = [];
for (let ti = 0; ti < toParse.length; ti++) {
nodes.push(transformDeclaration.call(self, toParse[ti]));
}
return nodes;
}
}
rulesets() {
if (!this.rules) { return []; }
/** @type {Node[]} */
const filtRules = [];
const rules = this.rules;
/** @type {number} */
let i;
/** @type {Node} */
let rule;
for (i = 0; (rule = rules[i]); i++) {
if (/** @type {RuleNode} */ (rule).isRuleset) {
filtRules.push(rule);
}
}
return filtRules;
}
/** @param {Node} rule */
prependRule(rule) {
const rules = this.rules;
if (rules) {
rules.unshift(rule);
} else {
this.rules = [ rule ];
}
this.setParent(rule, this);
}
/**
* @param {Selector} selector
* @param {Ruleset | null} [self]
* @param {((rule: Node) => boolean)} [filter]
* @returns {{ rule: Node, path: Node[] }[]}
*/
find(selector, self, filter) {
self = self || this;
/** @type {{ rule: Node, path: Node[] }[]} */
const rules = [];
/** @type {number | undefined} */
let match;
/** @type {{ rule: Node, path: Node[] }[]} */
let foundMixins;
const key = selector.toCSS(/** @type {EvalContext} */ ({}));
if (key in this._lookups) { return /** @type {{ rule: Node, path: Node[] }[]} */ (this._lookups[key]); }
this.rulesets().forEach(function (rule) {
if (rule !== self) {
for (let j = 0; j < /** @type {RuleNode} */ (rule).selectors.length; j++) {
match = selector.match(/** @type {RuleNode} */ (rule).selectors[j]);
if (match) {
if (selector.elements.length > match) {
if (!filter || filter(rule)) {
foundMixins = /** @type {Ruleset} */ (/** @type {unknown} */ (rule)).find(new Selector(selector.elements.slice(match)), self, filter);
for (let 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;
}
/**
* @param {EvalContext} context
* @param {CSSOutput} output
*/
genCSS(context, output) {
/** @type {number} */
let i;
/** @type {number} */
let j;
/** @type {Node[]} */
const charsetRuleNodes = [];
/** @type {Node[]} */
let ruleNodes = [];
let // Line number debugging
debugInfo;
/** @type {Node} */
let rule;
/** @type {Selector[]} */
let path;
context.tabLevel = (context.tabLevel || 0);
if (!this.root) {
context.tabLevel++;
}
const tabRuleStr = context.compress ? '' : Array(context.tabLevel + 1).join(' ');
const tabSetStr = context.compress ? '' : Array(context.tabLevel).join(' ');
/** @type {string} */
let sep;
let charsetNodeIndex = 0;
let importNodeIndex = 0;
for (i = 0; (rule = /** @type {Node[]} */ (this.rules)[i]); i++) {
if (rule instanceof Comment) {
if (importNodeIndex === i) {
importNodeIndex++;
}
ruleNodes.push(rule);
} else if (/** @type {RuleNode} */ (rule).isCharset && /** @type {RuleNode} */ (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 = getDebugInfo(context, /** @type {{ debugInfo: { lineNumber: number, fileName: string } }} */ (/** @type {unknown} */ (this)), tabSetStr);
if (debugInfo) {
output.add(debugInfo);
output.add(tabSetStr);
}
const paths = /** @type {Selector[][]} */ (this.paths);
const pathCnt = paths.length;
/** @type {number} */
let 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); }
/** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector = true;
path[0].genCSS(context, output);
/** @type {EvalContext & { firstSelector?: boolean }} */ (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;
}
const currentLastRule = context.lastRule;
if (rule.isRulesetLike()) {
context.lastRule = false;
}
if (rule.genCSS) {
rule.genCSS(context, output);
} else if (rule.value) {
output.add(/** @type {string} */ (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');
}
}
/**
* @param {Selector[][]} paths
* @param {Selector[][]} context
* @param {Selector[]} selectors
*/
joinSelectors(paths, context, selectors) {
for (let s = 0; s < selectors.length; s++) {
this.joinSelector(paths, context, selectors[s]);
}
}
/**
* @param {Selector[][]} paths
* @param {Selector[][]} context
* @param {Selector} selector
*/
joinSelector(paths, context, selector) {
/**
* @param {Selector[]} elementsToPak
* @param {Element} originalElement
* @returns {Paren}
*/
function createParenthesis(elementsToPak, originalElement) {
/** @type {Paren} */
let replacementParen;
/** @type {number} */
let j;
if (elementsToPak.length === 0) {
replacementParen = new Paren(elementsToPak[0]);
} else {
const 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;
}
/**
* @param {Paren | Selector} containedElement
* @param {Element} originalElement
* @returns {Selector}
*/
function createSelector(containedElement, originalElement) {
/** @type {Element} */
let element;
/** @type {Selector} */
let selector;
element = new Element(null, containedElement, originalElement.isVariable, originalElement._index, originalElement._fileInfo);
selector = new Selector([element]);
return selector;
}
/**
* @param {Selector[]} beginningPath
* @param {Selector[]} addPath
* @param {Element} replacedElement
* @param {Selector} originalSelector
* @returns {Selector[]}
*/
function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {
/** @type {Selector[]} */
let newSelectorPath;
/** @type {Selector} */
let lastSelector;
/** @type {Selector} */
let 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 = utils.copyArray(beginningPath);
lastSelector = newSelectorPath.pop();
newJoinedSelector = originalSelector.createDerived(utils.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
let combinator = replacedElement.combinator;
const 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) {
let restOfPath = addPath.slice(1);
restOfPath = restOfPath.map(function (/** @type {Selector} */ selector) {
return selector.createDerived(selector.elements, []);
});
newSelectorPath = newSelectorPath.concat(restOfPath);
}
return newSelectorPath;
}
/**
* @param {Selector[][]} beginningPath
* @param {Selector[]} addPaths
* @param {Element} replacedElement
* @param {Selector} originalSelector
* @param {Selector[][]} result
* @returns {Selector[][]}
*/
function addAllReplacementsIntoPath( beginningPath, addPaths, replacedElement, originalSelector, result) {
/** @type {number} */
let j;
for (j = 0; j < beginningPath.length; j++) {
const newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
result.push(newSelectorPath);
}
return result;
}
/**
* @param {Element[]} elements
* @param {Selector[][]} selectors
*/
function mergeElementsOnToSelectors(elements, selectors) {
/** @type {number} */
let i;
/** @type {Selector[]} */
let 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));
}
}
}
/**
* @param {Selector[][]} paths
* @param {Selector[][]} context
* @param {Selector} inSelector
* @returns {boolean}
*/
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]]
//
/** @type {number} */
let i;
/** @type {number} */
let j;
/** @type {number} */
let k;
/** @type {Element[]} */
let currentElements;
/** @type {Selector[][]} */
let newSelectors;
/** @type {Selector[][]} */
let selectorsMultiplied;
/** @type {Selector[]} */
let sel;
/** @type {Element} */
let el;
let hadParentSelector = false;
/** @type {number} */
let length;
/** @type {Selector} */
let lastSelector;
/**
* @param {Element} element
* @returns {Selector | null}
*/
function findNestedSelector(element) {
/** @type {Node} */
let maybeSelector;
if (!(element.value instanceof Paren)) {
return null;
}
maybeSelector = /** @type {Node} */ (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 !== '&') {
const 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);
/** @type {Selector[][]} */
const nestedPaths = [];
/** @type {boolean | undefined} */
let replaced;
/** @type {Selector[][]} */
const replacedNewSelectors = [];
// Check if this is a comma-separated selector list inside the paren
// e.g. :not(&.a, &.b) produces Selector([Selector, Anonymous(','), Selector])
const hasSubSelectors = nestedSelector.elements.some(e => e instanceof Selector);
if (hasSubSelectors) {
// Process each sub-selector individually
/** @type {(Element | Selector)[]} */
const resolvedElements = [];
for (const subEl of nestedSelector.elements) {
if (subEl instanceof Selector) {
/** @type {Selector[][]} */
const subPaths = [];
const subReplaced = replaceParentSelector(subPaths, context, subEl);
replaced = replaced || subReplaced;
if (subPaths.length > 0 && subPaths[0].length > 0) {
resolvedElements.push(subPaths[0][0]);
} else {
resolvedElements.push(subEl);
}
} else {
resolvedElements.push(subEl);
}
}
hadParentSelector = hadParentSelector || /** @type {boolean} */ (replaced);
const resolvedNestedSelector = new Selector(resolvedElements);
const replacementSelector = createSelector(createParenthesis([resolvedNestedSelector], el), el);
addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);
} else {
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++) {
const 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
const 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;
}
/**
* @param {VisibilityInfo} visibilityInfo
* @param {Selector} deriveFrom
*/
function deriveSelector(visibilityInfo, deriveFrom) {
const newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);
newSelector.copyVisibilityInfo(visibilityInfo);
return newSelector;
}
// joinSelector code follows
/** @type {number} */
let i;
/** @type {Selector[][]} */
let newPaths;
/** @type {boolean} */
let hadParentSelector;
newPaths = [];
hadParentSelector = replaceParentSelector(newPaths, context, selector);
if (!hadParentSelector) {
if (context.length > 0) {
newPaths = [];
for (i = 0; i < context.length; i++) {
const 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]);
}
}
}
export default Ruleset;
================================================
FILE: packages/less/lib/less/tree/selector.js
================================================
// @ts-check
import Node from './node.js';
import Element from './element.js';
import LessError from '../less-error.js';
import * as utils from '../utils.js';
import Parser from '../parser/parser.js';
/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo, TreeVisitor } from './node.js' */
class Selector extends Node {
get type() { return 'Selector'; }
/**
* @param {(Element | Selector)[] | string} [elements]
* @param {Node[] | null} [extendList]
* @param {Node | null} [condition]
* @param {number} [index]
* @param {FileInfo} [currentFileInfo]
* @param {VisibilityInfo} [visibilityInfo]
*/
constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
super();
/** @type {Node[] | null | undefined} */
this.extendList = extendList;
/** @type {Node | null | undefined} */
this.condition = condition;
/** @type {boolean | Node} */
this.evaldCondition = !condition;
this._index = index;
this._fileInfo = currentFileInfo;
/** @type {Element[]} */
this.elements = this.getElements(elements);
/** @type {string[] | undefined} */
this.mixinElements_ = undefined;
/** @type {boolean | undefined} */
this.mediaEmpty = undefined;
this.copyVisibilityInfo(visibilityInfo);
this.setParent(this.elements, this);
}
/** @param {TreeVisitor} visitor */
accept(visitor) {
if (this.elements) {
this.elements = /** @type {Element[]} */ (visitor.visitArray(this.elements));
}
if (this.extendList) {
this.extendList = visitor.visitArray(this.extendList);
}
if (this.condition) {
this.condition = visitor.visit(this.condition);
}
}
/**
* @param {Element[]} elements
* @param {Node[] | null} [extendList]
* @param {boolean | Node} [evaldCondition]
*/
createDerived(elements, extendList, evaldCondition) {
elements = this.getElements(elements);
const newSelector = new Selector(elements, extendList || this.extendList,
null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
newSelector.evaldCondition = (!utils.isNullOrUndefined(evaldCondition)) ? evaldCondition : this.evaldCondition;
newSelector.mediaEmpty = this.mediaEmpty;
return newSelector;
}
/**
* @param {(Element | Selector)[] | string | null | undefined} els
* @returns {Element[]}
*/
getElements(els) {
if (!els) {
return [new Element('', '&', false, this._index, this._fileInfo)];
}
if (typeof els === 'string') {
const fileInfo = this._fileInfo;
const parse = this.parse;
new (/** @type {new (...args: unknown[]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(parse.context, parse.importManager, fileInfo, this._index).parseNode(
els,
['selector'],
function(/** @type {{ index: number, message: string } | null} */ err, /** @type {Selector[]} */ result) {
if (err) {
throw new LessError({
index: err.index,
message: err.message
}, parse.imports, /** @type {string} */ (/** @type {FileInfo} */ (fileInfo).filename));
}
els = result[0].elements;
});
}
return /** @type {Element[]} */ (els);
}
createEmptySelectors() {
const el = new Element('', '&', false, this._index, this._fileInfo), sels = [new Selector([el], null, null, this._index, this._fileInfo)];
sels[0].mediaEmpty = true;
return sels;
}
/**
* @param {Selector} other
* @returns {number}
*/
match(other) {
const elements = this.elements;
const len = elements.length;
let olen;
let i;
/** @type {string[]} */
const mixinEls = other.mixinElements();
olen = mixinEls.length;
if (olen === 0 || len < olen) {
return 0;
} else {
for (i = 0; i < olen; i++) {
if (elements[i].value !== mixinEls[i]) {
return 0;
}
}
}
return olen; // return number of matched elements
}
/** @returns {string[]} */
mixinElements() {
if (this.mixinElements_) {
return this.mixinElements_;
}
/** @type {string[] | null} */
let elements = this.elements.map( function(v) {
return /** @type {string} */ (v.combinator.value) + (/** @type {{ value: string }} */ (v.value).value || v.value);
}).join('').match(/[,&#*.\w-]([\w-]|(\\.))*/g);
if (elements) {
if (elements[0] === '&') {
elements.shift();
}
} else {
elements = [];
}
return (this.mixinElements_ = elements);
}
isJustParentSelector() {
return !this.mediaEmpty &&
this.elements.length === 1 &&
this.elements[0].value === '&' &&
(this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
}
/** @param {EvalContext} context */
eval(context) {
const evaldCondition = this.condition && this.condition.eval(context);
let elements = this.elements;
/** @type {Node[] | null | undefined} */
let extendList = this.extendList;
if (elements) {
const evaldElements = new Array(elements.length);
for (let i = 0; i < elements.length; i++) {
evaldElements[i] = elements[i].eval(context);
}
elements = evaldElements;
}
if (extendList) {
const evaldExtends = new Array(extendList.length);
for (let i = 0; i < extendList.length; i++) {
evaldExtends[i] = extendList[i].eval(context);
}
extendList = evaldExtends;
}
return this.createDerived(elements, extendList, evaldCondition);
}
/**
* @param {EvalContext} context
* @param {CSSOutput} output
*/
genCSS(context, output) {
let i, element;
if ((!context || !/** @type {EvalContext & { firstSelector?: boolean }} */ (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);
}
}
getIsOutput() {
return this.evaldCondition;
}
}
export default Selector;
================================================
FILE: packages/less/lib/less/tree/unicode-descriptor.js
================================================
// @ts-check
import Node from './node.js';
class UnicodeDescriptor extends Node {
get type() { return 'UnicodeDescriptor'; }
/** @param {string} value */
constructor(value) {
super();
this.value = value;
}
}
export default UnicodeDescriptor;
================================================
FILE: packages/less/lib/less/tree/unit.js
================================================
// @ts-check
import Node from './node.js';
import unitConversions from '../data/unit-conversions.js';
import * as utils from '../utils.js';
/** @import { EvalContext, CSSOutput } from './node.js' */
class Unit extends Node {
get type() { return 'Unit'; }
/**
* @param {string[]} [numerator]
* @param {string[]} [denominator]
* @param {string} [backupUnit]
*/
constructor(numerator, denominator, backupUnit) {
super();
/** @type {string[]} */
this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
/** @type {string[]} */
this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
if (backupUnit) {
/** @type {string | undefined} */
this.backupUnit = backupUnit;
} else if (numerator && numerator.length) {
this.backupUnit = numerator[0];
}
}
clone() {
return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);
}
/**
* @param {EvalContext} context
* @param {CSSOutput} output
*/
genCSS(context, output) {
// Dimension checks the unit is singular and throws an error if in strict math mode.
const 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]);
}
}
toString() {
let i, returnStr = this.numerator.join('*');
for (i = 0; i < this.denominator.length; i++) {
returnStr += `/${this.denominator[i]}`;
}
return returnStr;
}
/**
* @param {Unit} other
* @returns {0 | undefined}
*/
compare(other) {
return this.is(other.toString()) ? 0 : undefined;
}
/** @param {string} unitString */
is(unitString) {
return this.toString().toUpperCase() === unitString.toUpperCase();
}
isLength() {
return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS(/** @type {import('./node.js').EvalContext} */ ({})));
}
isEmpty() {
return this.numerator.length === 0 && this.denominator.length === 0;
}
isSingular() {
return this.numerator.length <= 1 && this.denominator.length === 0;
}
/** @param {(atomicUnit: string, denominator: boolean) => string} callback */
map(callback) {
let 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);
}
}
/** @returns {{ [groupName: string]: string }} */
usedUnits() {
/** @type {{ [unitName: string]: number }} */
let group;
/** @type {{ [groupName: string]: string }} */
const result = {};
/** @type {(atomicUnit: string) => string} */
let mapUnit;
/** @type {string} */
let groupName;
mapUnit = function (atomicUnit) {
// eslint-disable-next-line no-prototype-builtins
if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
result[groupName] = atomicUnit;
}
return atomicUnit;
};
for (groupName in unitConversions) {
// eslint-disable-next-line no-prototype-builtins
if (unitConversions.hasOwnProperty(groupName)) {
group = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);
this.map(mapUnit);
}
}
return result;
}
cancel() {
/** @type {{ [unit: string]: number }} */
const counter = {};
/** @type {string} */
let atomicUnit;
let 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) {
// eslint-disable-next-line no-prototype-builtins
if (counter.hasOwnProperty(atomicUnit)) {
const 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();
}
}
export default Unit;
================================================
FILE: packages/less/lib/less/tree/url.js
================================================
// @ts-check
/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo } from './node.js' */
import Node from './node.js';
/**
* @param {string} path
* @returns {string}
*/
function escapePath(path) {
return path.replace(/[()'"\s]/g, function(match) { return `\\${match}`; });
}
class URL extends Node {
get type() { return 'Url'; }
/**
* @param {Node} val
* @param {number} index
* @param {FileInfo} currentFileInfo
* @param {boolean} [isEvald]
*/
constructor(val, index, currentFileInfo, isEvald) {
super();
this.value = val;
this._index = index;
this._fileInfo = currentFileInfo;
/** @type {boolean | undefined} */
this.isEvald = isEvald;
}
/** @param {TreeVisitor} visitor */
accept(visitor) {
this.value = visitor.visit(/** @type {Node} */ (this.value));
}
/**
* @param {EvalContext} context
* @param {CSSOutput} output
*/
genCSS(context, output) {
output.add('url(');
/** @type {Node} */ (this.value).genCSS(context, output);
output.add(')');
}
/** @param {EvalContext} context */
eval(context) {
const val = /** @type {Node} */ (this.value).eval(context);
let 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(/** @type {string} */ (val.value))) {
if (!/** @type {import('./quoted.js').default} */ (val).quote) {
rootpath = escapePath(rootpath);
}
val.value = context.rewritePath(/** @type {string} */ (val.value), rootpath);
} else {
val.value = context.normalizePath(/** @type {string} */ (val.value));
}
// Add url args if enabled
if (context.urlArgs) {
if (!/** @type {string} */ (val.value).match(/^\s*data:/)) {
const delimiter = /** @type {string} */ (val.value).indexOf('?') === -1 ? '?' : '&';
const urlArgs = delimiter + context.urlArgs;
if (/** @type {string} */ (val.value).indexOf('#') !== -1) {
val.value = /** @type {string} */ (val.value).replace('#', `${urlArgs}#`);
} else {
val.value += urlArgs;
}
}
}
}
return new URL(val, this.getIndex(), this.fileInfo(), true);
}
}
export default URL;
================================================
FILE: packages/less/lib/less/tree/value.js
================================================
// @ts-check
/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
import Node from './node.js';
class Value extends Node {
get type() { return 'Value'; }
/** @param {Node[] | Node} value */
constructor(value) {
super();
if (!value) {
throw new Error('Value requires an array argument');
}
if (!Array.isArray(value)) {
this.value = [ value ];
}
else {
this.value = value;
}
}
/** @param {TreeVisitor} visitor */
accept(visitor) {
if (this.value) {
this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));
}
}
/**
* @param {EvalContext} context
* @returns {Node}
*/
eval(context) {
const value = /** @type {Node[]} */ (this.value);
if (value.length === 1) {
return value[0].eval(context);
} else {
return new Value(value.map(function (v) {
return v.eval(context);
}));
}
}
/**
* @param {EvalContext} context
* @param {CSSOutput} output
*/
genCSS(context, output) {
const value = /** @type {Node[]} */ (this.value);
let i;
for (i = 0; i < value.length; i++) {
value[i].genCSS(context, output);
if (i + 1 < value.length) {
output.add((context && context.compress) ? ',' : ', ');
}
}
}
}
export default Value;
================================================
FILE: packages/less/lib/less/tree/variable-call.js
================================================
// @ts-check
/** @import { EvalContext, FileInfo } from './node.js' */
import Node from './node.js';
import Variable from './variable.js';
import Ruleset from './ruleset.js';
import DetachedRuleset from './detached-ruleset.js';
import LessError from '../less-error.js';
class VariableCall extends Node {
get type() { return 'VariableCall'; }
/**
* @param {string} variable
* @param {number} index
* @param {FileInfo} currentFileInfo
*/
constructor(variable, index, currentFileInfo) {
super();
this.variable = variable;
this._index = index;
this._fileInfo = currentFileInfo;
this.allowRoot = true;
}
/**
* @param {EvalContext} context
* @returns {Node}
*/
eval(context) {
let rules;
/** @type {DetachedRuleset | Node} */
let detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);
const error = new LessError({message: `Could not evaluate variable call ${this.variable}`});
if (!(/** @type {DetachedRuleset} */ (detachedRuleset)).ruleset) {
const dr = /** @type {Node & { rules?: Node[] }} */ (detachedRuleset);
if (dr.rules) {
rules = detachedRuleset;
}
else if (Array.isArray(detachedRuleset)) {
rules = new Ruleset(null, detachedRuleset);
}
else if (Array.isArray(detachedRuleset.value)) {
rules = new Ruleset(null, detachedRuleset.value);
}
else {
throw error;
}
detachedRuleset = new DetachedRuleset(rules);
}
const dr = /** @type {DetachedRuleset} */ (detachedRuleset);
if (dr.ruleset) {
return dr.callEval(context);
}
throw error;
}
}
export default VariableCall;
================================================
FILE: packages/less/lib/less/tree/variable.js
================================================
// @ts-check
/** @import { EvalContext, FileInfo } from './node.js' */
import Node from './node.js';
import Call from './call.js';
import Ruleset from './ruleset.js';
class Variable extends Node {
get type() { return 'Variable'; }
/**
* @param {string} name
* @param {number} [index]
* @param {FileInfo} [currentFileInfo]
*/
constructor(name, index, currentFileInfo) {
super();
this.name = name;
this._index = index;
this._fileInfo = currentFileInfo;
/** @type {boolean | undefined} */
this.evaluating = undefined;
}
/**
* @param {EvalContext} context
* @returns {Node}
*/
eval(context) {
let variable, 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) {
const v = /** @type {Ruleset} */ (frame).variable(name);
if (v) {
if (v.important) {
const 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], 0, undefined)).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() };
}
}
/**
* @param {Node[]} obj
* @param {(frame: Node) => Node | undefined} fun
* @returns {Node | null}
*/
find(obj, fun) {
for (let i = 0, r; i < obj.length; i++) {
r = fun.call(obj, obj[i]);
if (r) { return r; }
}
return null;
}
}
export default Variable;
================================================
FILE: packages/less/lib/less/utils.js
================================================
/* jshint proto: true */
import * as Constants from './constants.js';
import { copy } from 'copy-anything';
export function getLocation(index, inputStream) {
let n = index + 1;
let line = null;
let 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
};
}
export function copyArray(arr) {
let i;
const length = arr.length;
const copy = new Array(length);
for (i = 0; i < length; i++) {
copy[i] = arr[i];
}
return copy;
}
export function clone(obj) {
const cloned = {};
for (const prop in obj) {
if (Object.prototype.hasOwnProperty.call(obj, prop)) {
cloned[prop] = obj[prop];
}
}
return cloned;
}
export function defaults(obj1, obj2) {
let newObj = obj2 || {};
if (!obj2._defaults) {
newObj = {};
const defaults = copy(obj1);
newObj._defaults = defaults;
const cloned = obj2 ? copy(obj2) : {};
Object.assign(newObj, defaults, cloned);
}
return newObj;
}
export function copyOptions(obj1, obj2) {
if (obj2 && obj2._defaults) {
return obj2;
}
const opts = defaults(obj1, obj2);
if (opts.strictMath) {
opts.math = Constants.Math.PARENS;
}
// Back compat with changed relativeUrls option
if (opts.relativeUrls) {
opts.rewriteUrls = Constants.RewriteUrls.ALL;
}
if (typeof opts.math === 'string') {
switch (opts.math.toLowerCase()) {
case 'always':
opts.math = Constants.Math.ALWAYS;
break;
case 'parens-division':
opts.math = Constants.Math.PARENS_DIVISION;
break;
case 'strict':
case 'parens':
opts.math = Constants.Math.PARENS;
break;
default:
opts.math = Constants.Math.PARENS;
}
}
if (typeof opts.rewriteUrls === 'string') {
switch (opts.rewriteUrls.toLowerCase()) {
case 'off':
opts.rewriteUrls = Constants.RewriteUrls.OFF;
break;
case 'local':
opts.rewriteUrls = Constants.RewriteUrls.LOCAL;
break;
case 'all':
opts.rewriteUrls = Constants.RewriteUrls.ALL;
break;
}
}
return opts;
}
export function merge(obj1, obj2) {
for (const prop in obj2) {
if (Object.prototype.hasOwnProperty.call(obj2, prop)) {
obj1[prop] = obj2[prop];
}
}
return obj1;
}
export function flattenArray(arr, result = []) {
for (let i = 0, length = arr.length; i < length; i++) {
const value = arr[i];
if (Array.isArray(value)) {
flattenArray(value, result);
} else {
if (value !== undefined) {
result.push(value);
}
}
}
return result;
}
export function isNullOrUndefined(val) {
return val === null || val === undefined
}
================================================
FILE: packages/less/lib/less/visitors/extend-visitor.js
================================================
/* eslint-disable no-unused-vars */
/**
* @todo - Remove unused when JSDoc types are added for visitor methods
*/
import tree from '../tree/index.js';
import Visitor from './visitor.js';
import logger from '../logger.js';
import * as utils from '../utils.js';
/* jshint loopfunc:true */
class ExtendFinderVisitor {
constructor() {
this._visitor = new Visitor(this);
this.contexts = [];
this.allExtendsStack = [[]];
}
run(root) {
root = this._visitor.visit(root);
root.allExtends = this.allExtendsStack[0];
return root;
}
visitDeclaration(declNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitMixinDefinition(mixinDefinitionNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitRuleset(rulesetNode, visitArgs) {
if (rulesetNode.root) {
return;
}
let i;
let j;
let extend;
const allSelectorsExtendList = [];
let extendList;
// get &:extend(.a); rules which apply to all selectors in this ruleset
const rules = rulesetNode.rules, 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
const paths = rulesetNode.paths;
for (i = 0; i < paths.length; i++) {
const selectorPath = paths[i], selector = selectorPath[selectorPath.length - 1], selExtendList = selector.extendList;
extendList = selExtendList ? utils.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);
}
visitRulesetOut(rulesetNode) {
if (!rulesetNode.root) {
this.contexts.length = this.contexts.length - 1;
}
}
visitMedia(mediaNode, visitArgs) {
mediaNode.allExtends = [];
this.allExtendsStack.push(mediaNode.allExtends);
}
visitMediaOut(mediaNode) {
this.allExtendsStack.length = this.allExtendsStack.length - 1;
}
visitAtRule(atRuleNode, visitArgs) {
atRuleNode.allExtends = [];
this.allExtendsStack.push(atRuleNode.allExtends);
}
visitAtRuleOut(atRuleNode) {
this.allExtendsStack.length = this.allExtendsStack.length - 1;
}
}
class ProcessExtendsVisitor {
constructor() {
this._visitor = new Visitor(this);
}
run(root) {
const 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];
const newRoot = this._visitor.visit(root);
this.checkExtendsForNonMatched(root.allExtends);
return newRoot;
}
checkExtendsForNonMatched(extendList) {
const indices = this.extendIndices;
extendList.filter(function(extend) {
return !extend.hasFoundMatches && extend.parent_ids.length == 1;
}).forEach(function(extend) {
let selector = '_unknown_';
try {
selector = extend.selector.toCSS({});
}
catch (_) {}
if (!indices[`${extend.index} ${selector}`]) {
indices[`${extend.index} ${selector}`] = true;
/**
* @todo Shouldn't this be an error? To alert the developer
* that they may have made an error in the selector they are
* targeting?
*/
logger.warn(`WARNING: extend '${selector}' has no matches`);
}
});
}
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
let extendIndex;
let targetExtendIndex;
let matches;
const extendsToAdd = [];
let newSelector;
const extendVisitor = this;
let selectorPath;
let extend;
let targetExtend;
let 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) {
const 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) {
let selectorOne = '{unable to calculate}';
let 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;
}
}
visitDeclaration(ruleNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitMixinDefinition(mixinDefinitionNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitSelector(selectorNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitRuleset(rulesetNode, visitArgs) {
if (rulesetNode.root) {
return;
}
let matches;
const allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];
const selectorsToAdd = [];
const paths = rulesetNode.paths;
const pathCount = paths.length;
// look at each selector path in the ruleset, find any extend matches and then copy, find and replace
for (let extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
const extend = allExtends[extendIndex];
for (let pathIndex = 0; pathIndex < pathCount; pathIndex++) {
const selectorPath = paths[pathIndex];
// extending extends happens initially, before the main pass
if (rulesetNode.extendOnEveryPath) { continue; }
const extendList = selectorPath[selectorPath.length - 1].extendList;
if (extendList && extendList.length) { continue; }
matches = this.findMatch(extend, selectorPath);
if (matches.length) {
extend.hasFoundMatches = true;
const selfSelectors = extend.selfSelectors;
const isVisible = extend.isVisible();
for (let si = 0; si < selfSelectors.length; si++) {
selectorsToAdd.push(this.extendSelector(matches, selectorPath, selfSelectors[si], isVisible));
}
}
}
}
rulesetNode.paths = paths.concat(selectorsToAdd);
}
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
//
let haystackSelectorIndex;
let hackstackSelector;
let hackstackElementIndex;
let haystackElement;
let targetCombinator;
let i;
const needleElements = extend.selector.elements;
const potentialMatches = [];
let potentialMatch;
const 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 (!this.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;
}
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 (let 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;
}
extendSelector(matches, selectorPath, replacementSelector, isVisible) {
// for a set of matches, replace each match with the replacement selector
let currentSelectorPathIndex = 0, currentSelectorPathElementIndex = 0, path = [], matchIndex, selector, firstElement, match, 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
const derived = currentValue.createDerived(currentValue.elements);
if (isVisible) {
derived.ensureVisibility();
} else {
derived.ensureInvisibility();
}
return derived;
});
return path;
}
visitMedia(mediaNode, visitArgs) {
let newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
this.allExtendsStack.push(newAllExtends);
}
visitMediaOut(mediaNode) {
const lastIndex = this.allExtendsStack.length - 1;
this.allExtendsStack.length = lastIndex;
}
visitAtRule(atRuleNode, visitArgs) {
let newAllExtends = atRuleNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, atRuleNode.allExtends));
this.allExtendsStack.push(newAllExtends);
}
visitAtRuleOut(atRuleNode) {
const lastIndex = this.allExtendsStack.length - 1;
this.allExtendsStack.length = lastIndex;
}
}
export default ProcessExtendsVisitor;
================================================
FILE: packages/less/lib/less/visitors/import-sequencer.js
================================================
class ImportSequencer {
constructor(onSequencerEmpty) {
this.imports = [];
this.variableImports = [];
this._onSequencerEmpty = onSequencerEmpty;
this._currentDepth = 0;
}
addImport(callback) {
const importSequencer = this,
importItem = {
callback,
args: null,
isReady: false
};
this.imports.push(importItem);
return function() {
importItem.args = Array.prototype.slice.call(arguments, 0);
importItem.isReady = true;
importSequencer.tryRun();
};
}
addVariableImport(callback) {
this.variableImports.push(callback);
}
tryRun() {
this._currentDepth++;
try {
while (true) {
while (this.imports.length > 0) {
const 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;
}
const variableImport = this.variableImports[0];
this.variableImports = this.variableImports.slice(1);
variableImport();
}
} finally {
this._currentDepth--;
}
if (this._currentDepth === 0 && this._onSequencerEmpty) {
this._onSequencerEmpty();
}
}
}
export default ImportSequencer;
================================================
FILE: packages/less/lib/less/visitors/import-visitor.js
================================================
/* eslint-disable no-unused-vars */
/**
* @todo - Remove unused when JSDoc types are added for visitor methods
*/
import contexts from '../contexts.js';
import Visitor from './visitor.js';
import ImportSequencer from './import-sequencer.js';
import * as utils from '../utils.js';
const ImportVisitor = function(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 (root) {
try {
// process the contents
this._visitor.visit(root);
}
catch (e) {
this.error = e;
}
this.isFinished = true;
this._sequencer.tryRun();
},
_onSequencerEmpty: function() {
if (!this.isFinished) {
return;
}
this._finish(this.error);
},
visitImport: function (importNode, visitArgs) {
const inlineCSS = importNode.options.inline;
if (!importNode.css || inlineCSS) {
const context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));
const 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(importNode, context, importParent) {
let evaldImportNode;
const 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
const tryAppendLessExtension = evaldImportNode.css === undefined;
for (let i = 0; i < importParent.rules.length; i++) {
if (importParent.rules[i] === importNode) {
importParent.rules[i] = evaldImportNode;
break;
}
}
const onImported = this.onImported.bind(this, evaldImportNode, context), 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 (importNode, context, e, root, importedAtRoot, fullPath) {
if (e) {
if (!e.filename) {
e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename;
}
this.error = e;
}
const importVisitor = this,
inlineCSS = importNode.options.inline,
isPlugin = importNode.options.isPlugin,
isOptional = importNode.options.optional,
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;
const 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 (declNode, visitArgs) {
if (declNode.value.type === 'DetachedRuleset') {
this.context.frames.unshift(declNode);
} else {
visitArgs.visitDeeper = false;
}
},
visitDeclarationOut: function(declNode) {
if (declNode.value.type === 'DetachedRuleset') {
this.context.frames.shift();
}
},
visitAtRule: function (atRuleNode, visitArgs) {
if (atRuleNode.value) {
this.context.frames.unshift(atRuleNode);
} else if (atRuleNode.declarations && atRuleNode.declarations.length) {
if (atRuleNode.isRooted) {
this.context.frames.unshift(atRuleNode);
} else {
this.context.frames.unshift(atRuleNode.declarations[0]);
}
} else if (atRuleNode.rules && atRuleNode.rules.length) {
this.context.frames.unshift(atRuleNode);
}
},
visitAtRuleOut: function (atRuleNode) {
this.context.frames.shift();
},
visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
this.context.frames.unshift(mixinDefinitionNode);
},
visitMixinDefinitionOut: function (mixinDefinitionNode) {
this.context.frames.shift();
},
visitRuleset: function (rulesetNode, visitArgs) {
this.context.frames.unshift(rulesetNode);
},
visitRulesetOut: function (rulesetNode) {
this.context.frames.shift();
},
visitMedia: function (mediaNode, visitArgs) {
this.context.frames.unshift(mediaNode.rules[0]);
},
visitMediaOut: function (mediaNode) {
this.context.frames.shift();
}
};
export default ImportVisitor;
================================================
FILE: packages/less/lib/less/visitors/index.js
================================================
import Visitor from './visitor.js';
import ImportVisitor from './import-visitor.js';
import MarkVisibleSelectorsVisitor from './set-tree-visibility-visitor.js';
import ExtendVisitor from './extend-visitor.js';
import JoinSelectorVisitor from './join-selector-visitor.js';
import ToCSSVisitor from './to-css-visitor.js';
export default {
Visitor,
ImportVisitor,
MarkVisibleSelectorsVisitor,
ExtendVisitor,
JoinSelectorVisitor,
ToCSSVisitor
};
================================================
FILE: packages/less/lib/less/visitors/join-selector-visitor.js
================================================
/* eslint-disable no-unused-vars */
/**
* @todo - Remove unused when JSDoc types are added for visitor methods
*/
import Visitor from './visitor.js';
class JoinSelectorVisitor {
constructor() {
this.contexts = [[]];
this._visitor = new Visitor(this);
}
run(root) {
return this._visitor.visit(root);
}
visitDeclaration(declNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitMixinDefinition(mixinDefinitionNode, visitArgs) {
visitArgs.visitDeeper = false;
}
visitRuleset(rulesetNode, visitArgs) {
const context = this.contexts[this.contexts.length - 1];
const paths = [];
let 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;
}
}
visitRulesetOut(rulesetNode) {
this.contexts.length = this.contexts.length - 1;
}
visitMedia(mediaNode, visitArgs) {
const context = this.contexts[this.contexts.length - 1];
mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
}
visitAtRule(atRuleNode, visitArgs) {
const context = this.contexts[this.contexts.length - 1];
if (atRuleNode.declarations && atRuleNode.declarations.length) {
atRuleNode.declarations[0].root = (context.length === 0 || context[0].multiMedia);
}
else if (atRuleNode.rules && atRuleNode.rules.length) {
atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);
}
}
}
export default JoinSelectorVisitor;
================================================
FILE: packages/less/lib/less/visitors/set-tree-visibility-visitor.js
================================================
import Node from '../tree/node.js';
class SetTreeVisibilityVisitor {
/** @param {boolean} visible */
constructor(visible) {
this.visible = visible;
}
/** @param {Node} root */
run(root) {
this.visit(root);
}
/**
* @param {Node[]} nodes
* @returns {Node[]}
*/
visitArray(nodes) {
if (!nodes) {
return nodes;
}
const cnt = nodes.length;
let i;
for (i = 0; i < cnt; i++) {
this.visit(nodes[i]);
}
return nodes;
}
/**
* @param {*} node
* @returns {*}
*/
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;
}
}
export default SetTreeVisibilityVisitor;
================================================
FILE: packages/less/lib/less/visitors/to-css-visitor.js
================================================
/* eslint-disable no-unused-vars */
/**
* @todo - Remove unused when JSDoc types are added for visitor methods
*/
import tree from '../tree/index.js';
import Visitor from './visitor.js';
import mergeRules from '../tree/merge-rules.js';
class CSSVisitorUtils {
constructor(context) {
this._visitor = new Visitor(this);
this._context = context;
}
containsSilentNonBlockedChild(bodyRules) {
let rule;
if (!bodyRules) {
return false;
}
for (let 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;
}
keepOnlyVisibleChilds(owner) {
if (owner && owner.rules) {
owner.rules = owner.rules.filter(thing => thing.isVisible());
}
}
isEmpty(owner) {
return (owner && owner.rules)
? (owner.rules.length === 0) : true;
}
hasVisibleSelector(rulesetNode) {
return (rulesetNode && rulesetNode.paths)
? (rulesetNode.paths.length > 0) : false;
}
resolveVisibility(node) {
if (!node.blocksVisibility()) {
if (this.isEmpty(node)) {
return ;
}
return node;
}
const compiledRulesBody = node.rules[0];
this.keepOnlyVisibleChilds(compiledRulesBody);
if (this.isEmpty(compiledRulesBody)) {
return ;
}
node.ensureVisibility();
node.removeVisibilityBlock();
return node;
}
isVisibleRuleset(rulesetNode) {
if (rulesetNode.firstRoot) {
return true;
}
if (this.isEmpty(rulesetNode)) {
return false;
}
if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {
return false;
}
return true;
}
}
const ToCSSVisitor = function(context) {
this._visitor = new Visitor(this);
this._context = context;
this.utils = new CSSVisitorUtils(context);
};
ToCSSVisitor.prototype = {
isReplacing: true,
run: function (root) {
return this._visitor.visit(root);
},
visitDeclaration: function (declNode, visitArgs) {
if (declNode.blocksVisibility() || declNode.variable) {
return;
}
return declNode;
},
visitMixinDefinition: function (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 (extendNode, visitArgs) {
},
visitComment: function (commentNode, visitArgs) {
if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {
return;
}
return commentNode;
},
visitMedia: function(mediaNode, visitArgs) {
const originalRules = mediaNode.rules[0].rules;
mediaNode.accept(this._visitor);
visitArgs.visitDeeper = false;
return this.utils.resolveVisibility(mediaNode, originalRules);
},
visitImport: function (importNode, visitArgs) {
if (importNode.blocksVisibility()) {
return ;
}
return importNode;
},
visitAtRule: function(atRuleNode, visitArgs) {
if (atRuleNode.rules && atRuleNode.rules.length) {
return this.visitAtRuleWithBody(atRuleNode, visitArgs);
} else {
return this.visitAtRuleWithoutBody(atRuleNode, visitArgs);
}
},
visitAnonymous: function(anonymousNode, visitArgs) {
if (!anonymousNode.blocksVisibility()) {
anonymousNode.accept(this._visitor);
return anonymousNode;
}
},
visitAtRuleWithBody: function(atRuleNode, visitArgs) {
// if there is only one nested ruleset and that one has no path, then it is
// just fake ruleset
function hasFakeRuleset(atRuleNode) {
const bodyRules = atRuleNode.rules;
return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
}
function getBodyRules(atRuleNode) {
const 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
const 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(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) {
const 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(rules, isRoot) {
if (!rules) {
return;
}
for (let i = 0; i < rules.length; i++) {
const 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}' did not return a root node`,
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 (rulesetNode, visitArgs) {
// at this point rulesets are nested into each other
let rule;
const 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
const nodeRules = rulesetNode.rules;
let nodeRuleCnt = nodeRules ? nodeRules.length : 0;
for (let 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(rulesetNode) {
if (rulesetNode.paths) {
rulesetNode.paths = rulesetNode.paths
.filter(p => {
let 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(rules) {
if (!rules) { return; }
// remove duplicates
const ruleCache = {};
for (let i = rules.length - 1; i >= 0 ; i--) {
let rule = rules[i];
if (rule instanceof tree.Declaration) {
if (!Object.prototype.hasOwnProperty.call(ruleCache, rule.name)) {
ruleCache[rule.name] = rule;
} else {
let ruleList = ruleCache[rule.name];
if (!Array.isArray(ruleList)) {
const prevRuleCSS = ruleList.toCSS(this._context);
ruleList = ruleCache[rule.name] = [prevRuleCSS];
}
const ruleCSS = rule.toCSS(this._context);
if (ruleList.indexOf(ruleCSS) !== -1) {
rules.splice(i, 1);
} else {
ruleList.push(ruleCSS);
}
}
}
}
},
_mergeRules: mergeRules
};
export default ToCSSVisitor;
================================================
FILE: packages/less/lib/less/visitors/visitor.js
================================================
import tree from '../tree/index.js';
const _visitArgs = { visitDeeper: true };
let _hasIndexed = false;
function _noop(node) {
return node;
}
function indexNodeTypes(parent, ticker) {
// add .typeIndex to tree node types for lookup table
let key, 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;
}
class Visitor {
constructor(implementation) {
this._implementation = implementation;
this._visitInCache = {};
this._visitOutCache = {};
if (!_hasIndexed) {
indexNodeTypes(tree, 1);
_hasIndexed = true;
}
}
visit(node) {
if (!node) {
return node;
}
const nodeTypeIndex = node.typeIndex;
if (!nodeTypeIndex) {
// MixinCall args aren't a node type?
if (node.value && node.value.typeIndex) {
this.visit(node.value);
}
return node;
}
const impl = this._implementation;
let func = this._visitInCache[nodeTypeIndex];
let funcOut = this._visitOutCache[nodeTypeIndex];
const visitArgs = _visitArgs;
let 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) {
const newNode = func.call(impl, node, visitArgs);
if (node && impl.isReplacing) {
node = newNode;
}
}
if (visitArgs.visitDeeper && node) {
if (node.length) {
for (let i = 0, cnt = node.length; i < cnt; i++) {
if (node[i].accept) {
node[i].accept(this);
}
}
} else if (node.accept) {
node.accept(this);
}
}
if (funcOut != _noop) {
funcOut.call(impl, node);
}
return node;
}
visitArray(nodes, nonReplacing) {
if (!nodes) {
return nodes;
}
const cnt = nodes.length;
let i;
// Non-replacing
if (nonReplacing || !this._implementation.isReplacing) {
for (i = 0; i < cnt; i++) {
this.visit(nodes[i]);
}
return nodes;
}
// Replacing
const out = [];
for (i = 0; i < cnt; i++) {
const 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;
}
flatten(arr, out) {
if (!out) {
out = [];
}
let cnt, i, item, nestedCnt, j, 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;
}
}
export default Visitor;
================================================
FILE: packages/less/lib/less-browser/add-default-options.js
================================================
import {addDataAttr} from './utils.js';
import browser from './browser.js';
/**
* @param {Window} window
* @param {Record} options
*/
export default (window, options) => {
// use options from the current script tag data attribues
addDataAttr(options, browser.currentScript(window));
if (options.isFileProtocol === undefined) {
options.isFileProtocol = /^(file|(chrome|safari)(-extension)?|resource|qrc|app):/.test(window.location.protocol);
}
// Load styles asynchronously (default: false)
//
// This is set to `false` by default, so that the body
// doesn't start loading before the stylesheets are parsed.
// Setting this to `true` can result in flickering.
//
options.async = options.async || false;
options.fileAsync = options.fileAsync || false;
// Interval between watch polls
options.poll = options.poll || (options.isFileProtocol ? 1000 : 1500);
options.env = options.env || (window.location.hostname == '127.0.0.1' ||
window.location.hostname == '0.0.0.0' ||
window.location.hostname == 'localhost' ||
(window.location.port &&
window.location.port.length > 0) ||
options.isFileProtocol ? 'development'
: 'production');
const dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(window.location.hash);
if (dumpLineNumbers) {
options.dumpLineNumbers = dumpLineNumbers[1];
}
if (options.useFileCache === undefined) {
options.useFileCache = true;
}
if (options.onReady === undefined) {
options.onReady = true;
}
if (options.relativeUrls) {
options.rewriteUrls = 'all';
}
};
================================================
FILE: packages/less/lib/less-browser/bootstrap.js
================================================
/**
* Kicks off less and compiles any stylesheets
* used in the browser distributed version of less
* to kick-start less using the browser api
*/
import defaultOptions from '../less/default-options.js';
import addDefaultOptions from './add-default-options.js';
import root from './index.js';
const options = defaultOptions();
if (window.less) {
for (const key in window.less) {
if (Object.prototype.hasOwnProperty.call(window.less, key)) {
options[key] = window.less[key];
}
}
}
addDefaultOptions(window, options);
options.plugins = options.plugins || [];
if (window.LESS_PLUGINS) {
options.plugins = options.plugins.concat(window.LESS_PLUGINS);
}
const less = root(window, options);
export default less;
window.less = less;
let css;
let head;
let style;
// Always restore page visibility
function resolveOrReject(data) {
if (data.filename) {
console.warn(data);
}
if (!options.async) {
head.removeChild(style);
}
}
if (options.onReady) {
if (/!watch/.test(window.location.hash)) {
less.watch();
}
// Simulate synchronous stylesheet loading by hiding page rendering
if (!options.async) {
css = 'body { display: none !important }';
head = document.head || document.getElementsByTagName('head')[0];
style = document.createElement('style');
style.type = 'text/css';
if (style.styleSheet) {
style.styleSheet.cssText = css;
} else {
style.appendChild(document.createTextNode(css));
}
head.appendChild(style);
}
less.registerStylesheetsImmediately();
less.pageLoadFinished = less.refresh(less.env === 'development').then(resolveOrReject, resolveOrReject);
}
================================================
FILE: packages/less/lib/less-browser/browser.js
================================================
import * as utils from './utils.js';
export default {
createCSS: function (document, styles, sheet) {
// Strip the query-string
const href = sheet.href || '';
// If there is no title set, use the filename, minus the extension
const id = `less:${sheet.title || utils.extractId(href)}`;
// If this has already been inserted into the DOM, we may need to replace it
const oldStyleNode = document.getElementById(id);
let keepOldStyleNode = false;
// Create a new stylesheet node for insertion or (if necessary) replacement
const styleNode = document.createElement('style');
styleNode.setAttribute('type', 'text/css');
if (sheet.media) {
styleNode.setAttribute('media', sheet.media);
}
styleNode.id = id;
if (!styleNode.styleSheet) {
styleNode.appendChild(document.createTextNode(styles));
// If new contents match contents of oldStyleNode, don't replace oldStyleNode
keepOldStyleNode = (oldStyleNode !== null && oldStyleNode.childNodes.length > 0 && styleNode.childNodes.length > 0 &&
oldStyleNode.firstChild.nodeValue === styleNode.firstChild.nodeValue);
}
const head = document.getElementsByTagName('head')[0];
// If there is no oldStyleNode, just append; otherwise, only append if we need
// to replace oldStyleNode with an updated stylesheet
if (oldStyleNode === null || keepOldStyleNode === false) {
const nextEl = sheet && sheet.nextSibling || null;
if (nextEl) {
nextEl.parentNode.insertBefore(styleNode, nextEl);
} else {
head.appendChild(styleNode);
}
}
if (oldStyleNode && keepOldStyleNode === false) {
oldStyleNode.parentNode.removeChild(oldStyleNode);
}
// For IE.
// This needs to happen *after* the style element is added to the DOM, otherwise IE 7 and 8 may crash.
// See http://social.msdn.microsoft.com/Forums/en-US/7e081b65-878a-4c22-8e68-c10d39c2ed32/internet-explorer-crashes-appending-style-element-to-head
if (styleNode.styleSheet) {
try {
styleNode.styleSheet.cssText = styles;
} catch (e) {
throw new Error('Couldn\'t reassign styleSheet.cssText.');
}
}
},
currentScript: function(window) {
const document = window.document;
return document.currentScript || (() => {
const scripts = document.getElementsByTagName('script');
return scripts[scripts.length - 1];
})();
}
};
================================================
FILE: packages/less/lib/less-browser/cache.js
================================================
// Cache system is a bit outdated and could do with work
export default (window, options, logger) => {
let cache = null;
if (options.env !== 'development') {
try {
cache = (typeof window.localStorage === 'undefined') ? null : window.localStorage;
} catch (_) {}
}
return {
setCSS: function(path, lastModified, modifyVars, styles) {
if (cache) {
logger.info(`saving ${path} to cache.`);
try {
cache.setItem(path, styles);
cache.setItem(`${path}:timestamp`, lastModified);
if (modifyVars) {
cache.setItem(`${path}:vars`, JSON.stringify(modifyVars));
}
} catch (e) {
// TODO - could do with adding more robust error handling
logger.error(`failed to save "${path}" to local storage for caching.`);
}
}
},
getCSS: function(path, webInfo, modifyVars) {
const css = cache && cache.getItem(path);
const timestamp = cache && cache.getItem(`${path}:timestamp`);
let vars = cache && cache.getItem(`${path}:vars`);
modifyVars = modifyVars || {};
vars = vars || '{}'; // if not set, treat as the JSON representation of an empty object
if (timestamp && webInfo.lastModified &&
(new Date(webInfo.lastModified).valueOf() ===
new Date(timestamp).valueOf()) &&
JSON.stringify(modifyVars) === vars) {
// Use local copy
return css;
}
}
};
};
================================================
FILE: packages/less/lib/less-browser/error-reporting.js
================================================
import * as utils from './utils.js';
import browser from './browser.js';
export default (window, less, options) => {
function errorHTML(e, rootHref) {
const id = `less-error-message:${utils.extractId(rootHref || '')}`;
const template = '{line} {content} ${e.type || 'Syntax'}Error: ${e.message || 'There is an error in your .less file'}` +
` in ${filenameNoPath} `;
const errorline = (e, i, classname) => {
if (e.extract[i] !== undefined) {
errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
.replace(/\{class\}/, classname)
.replace(/\{content\}/, e.extract[i]));
}
};
if (e.line) {
errorline(e, 0, '');
errorline(e, 1, 'line');
errorline(e, 2, '');
content += `on line ${e.line}, column ${e.column + 1}:
`;
}
if (e.stack && (e.extract || options.logLevel >= 4)) {
content += `} options
* @param {HTMLElement | null} tag
*/
export function addDataAttr(options, tag) {
if (!tag) {return;} // in case of tag is null or undefined
for (const opt in tag.dataset) {
if (Object.prototype.hasOwnProperty.call(tag.dataset, opt)) {
if (opt === 'env' || opt === 'dumpLineNumbers' || opt === 'rootpath' || opt === 'errorReporting') {
options[opt] = tag.dataset[opt];
} else {
try {
options[opt] = JSON.parse(tag.dataset[opt]);
}
catch (_) {}
}
}
}
}
================================================
FILE: packages/less/lib/less-node/environment.js
================================================
import { createRequire } from 'module';
const require = createRequire(import.meta.url);
class SourceMapGeneratorFallback {
addMapping(){}
setSourceContent(){}
toJSON(){
return null;
}
};
export default {
encodeBase64: function encodeBase64(str) {
// Avoid Buffer constructor on newer versions of Node.js.
const buffer = (Buffer.from ? Buffer.from(str) : (new Buffer(str)));
return buffer.toString('base64');
},
mimeLookup: function (filename) {
try {
const mimeModule = require('mime');
return mimeModule ? mimeModule.lookup(filename) : "application/octet-stream";
} catch (e) {
return "application/octet-stream";
}
},
charsetLookup: function (mime) {
try {
const mimeModule = require('mime');
return mimeModule ? mimeModule.charsets.lookup(mime) : undefined;
} catch (e) {
return undefined;
}
},
getSourceMapGenerator: function getSourceMapGenerator() {
try {
const sourceMapModule = require('source-map');
return sourceMapModule ? sourceMapModule.SourceMapGenerator : SourceMapGeneratorFallback;
} catch (e) {
return SourceMapGeneratorFallback;
}
}
};
================================================
FILE: packages/less/lib/less-node/file-manager.js
================================================
import path from 'path';
import { createRequire } from 'module';
import fs from './fs.js';
import AbstractFileManager from '../less/environment/abstract-file-manager.js';
const require = createRequire(import.meta.url);
const FileManager = function() {}
FileManager.prototype = Object.assign(new AbstractFileManager(), {
supports() {
return true;
},
supportsSync() {
return true;
},
loadFile(filename, currentDirectory, options, environment, callback) {
let fullFilename;
const isAbsoluteFilename = this.isPathAbsolute(filename);
const filenamesTried = [];
const self = this;
const prefix = filename.slice(0, 1);
const explicit = prefix === '.' || prefix === '/';
let result = null;
let isNodeModule = false;
const npmPrefix = 'npm://';
options = options || {};
const paths = isAbsoluteFilename ? [''] : [currentDirectory];
if (options.paths) { paths.push.apply(paths, options.paths); }
if (!isAbsoluteFilename && paths.indexOf('.') === -1) { paths.push('.'); }
const prefixes = options.prefixes || [''];
const 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) {
function tryWithExtension() {
const 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;
}
}
if (i < paths.length) {
(function tryPrefix(j) {
if (j < prefixes.length) {
isNodeModule = false;
fullFilename = fileParts.rawPath + prefixes[j] + fileParts.filename;
if (paths[i]) {
if (paths[i].startsWith('#')) {
// Handling paths starting with '#'
fullFilename = paths[i].substr(1) + fullFilename;
}else{
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();
}
const readFileArgs = [fullFilename];
if (!options.rawBuffer) {
readFileArgs.push('utf-8');
}
if (options.syncImport) {
try {
const data = fs.readFileSync.apply(this, readFileArgs);
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);
}
fulfill({ contents: data, filename: fullFilename});
});
fs.readFile.apply(this, readFileArgs);
}
}
else {
tryPathIndex(i + 1);
}
})(0);
} else {
reject({ type: 'File', message: `'${filename}' wasn't found. Tried - ${filenamesTried.join(',')}` });
}
}(0));
}
},
loadFileSync(filename, currentDirectory, options, environment) {
options.syncImport = true;
return this.loadFile(filename, currentDirectory, options, environment);
}
});
export default FileManager;
================================================
FILE: packages/less/lib/less-node/fs.js
================================================
/** @typedef {import('fs')} FS */
import nodeFs from 'fs';
import { createRequire } from 'module';
const require = createRequire(import.meta.url);
/** @type {FS} */
let fs;
try {
fs = require('graceful-fs');
} catch (e) {
fs = nodeFs;
}
export default fs;
================================================
FILE: packages/less/lib/less-node/image-size.js
================================================
import { createRequire } from 'module';
import Dimension from '../less/tree/dimension.js';
import Expression from '../less/tree/expression.js';
import functionRegistry from './../less/functions/function-registry.js';
const require = createRequire(import.meta.url);
export default environment => {
function imageSize(functionContext, filePathNode) {
let filePath = filePathNode.value;
const currentFileInfo = functionContext.currentFileInfo;
const currentDirectory = currentFileInfo.rewriteUrls ?
currentFileInfo.currentDirectory : currentFileInfo.entryPath;
const fragmentStart = filePath.indexOf('#');
if (fragmentStart !== -1) {
filePath = filePath.slice(0, fragmentStart);
}
const fileManager = environment.getFileManager(filePath, currentDirectory, functionContext.context, environment, true);
if (!fileManager) {
throw {
type: 'File',
message: `Can not set up FileManager for ${filePathNode}`
};
}
const fileSync = fileManager.loadFileSync(filePath, currentDirectory, functionContext.context, environment);
if (fileSync.error) {
throw fileSync.error;
}
const sizeOf = require('image-size');
return sizeOf ? sizeOf(fileSync.filename) : {width: 0, height: 0};
}
const imageFunctions = {
'image-size': function(filePathNode) {
const size = imageSize(this, filePathNode);
return new Expression([
new Dimension(size.width, 'px'),
new Dimension(size.height, 'px')
]);
},
'image-width': function(filePathNode) {
const size = imageSize(this, filePathNode);
return new Dimension(size.width, 'px');
},
'image-height': function(filePathNode) {
const size = imageSize(this, filePathNode);
return new Dimension(size.height, 'px');
}
};
functionRegistry.addMultiple(imageFunctions);
};
================================================
FILE: packages/less/lib/less-node/index.js
================================================
import { createRequire } from 'module';
import environment from './environment.js';
import FileManager from './file-manager.js';
import UrlFileManager from './url-file-manager.js';
import createFromEnvironment from '../less/index.js';
import lesscHelper from './lessc-helper.js';
import PluginLoader from './plugin-loader.js';
import fs from './fs.js';
import defaultOptions from '../less/default-options.js';
import imageSize from './image-size.js';
const require = createRequire(import.meta.url);
const { version } = require('../../package.json');
const less = createFromEnvironment(environment, [new FileManager(), new UrlFileManager()], version);
// allow people to create less with their own environment
less.createFromEnvironment = createFromEnvironment;
less.lesscHelper = lesscHelper;
less.PluginLoader = PluginLoader;
less.fs = fs;
less.FileManager = FileManager;
less.UrlFileManager = UrlFileManager;
// Set up options
less.options = defaultOptions();
// provide image-size functionality
imageSize(less.environment);
export default less;
================================================
FILE: packages/less/lib/less-node/lessc-helper.js
================================================
// lessc_helper.js
//
// helper functions for lessc
const lessc_helper = {
// Stylize a string
stylize : function(str, style) {
const 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() {
console.log('usage: lessc [option option=parameter ...] [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(' --quiet Suppresses output of warnings.');
console.log(' --strict-imports (DEPRECATED) Ignores .less imports inside selector blocks. Has confusing behavior.');
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(' --source-map-no-annotation Excludes the sourceMappingURL comment from the output 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(' --disable-plugin-rule Disallow @plugin statements');
console.log('');
console.log(' --quiet-deprecations Suppress deprecation warnings only (keeps other warnings).');
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 (DEPRECATED) Outputs filename and line numbers.');
console.log(' TYPE can be either \'comments\', \'mediaquery\', or \'all\'.');
console.log(' The entire dumpLineNumbers option is deprecated.');
console.log(' Use sourcemaps (--source-map) instead.');
console.log(' All modes will be removed in a future version.');
console.log(' Note: \'mediaquery\' and \'all\' modes generate @media -sass-debug-info');
console.log(' which had short-lived usage and is no longer recommended.');
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: 
Add your contributions