} */ hash, /** @type {Node} */ r) {\n if (r instanceof Declaration && r.variable !== true) {\n const name = (/** @type {Node[]} */ (r.name).length === 1) && (/** @type {Node[]} */ (r.name)[0] instanceof Keyword) ?\n /** @type {string} */ (/** @type {Node[]} */ (r.name)[0].value) : /** @type {string} */ (r.name);\n // Properties don't overwrite as they can merge\n if (!hash[`$${name}`]) {\n hash[`$${name}`] = [ r ];\n }\n else {\n hash[`$${name}`].push(r);\n }\n }\n return hash;\n }, {});\n }\n return this._properties;\n }\n\n /** @param {string} name */\n variable(name) {\n const decl = this.variables()[name];\n if (decl) {\n return this.parseValue(decl);\n }\n }\n\n /** @param {string} name */\n property(name) {\n const decl = this.properties()[name];\n if (decl) {\n return this.parseValue(decl);\n }\n }\n\n lastDeclaration() {\n for (let i = /** @type {Node[]} */ (this.rules).length; i > 0; i--) {\n const decl = /** @type {Node[]} */ (this.rules)[i - 1];\n if (decl instanceof Declaration) {\n return this.parseValue(decl);\n }\n }\n }\n\n /** @param {Declaration | Declaration[]} toParse */\n parseValue(toParse) {\n const self = this;\n /** @param {Declaration} decl */\n function transformDeclaration(decl) {\n if (decl.value instanceof Anonymous && !/** @type {Declaration & { parsed?: boolean }} */ (decl).parsed) {\n if (typeof decl.value.value === 'string') {\n 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(\n decl.value.value,\n ['value', 'important'],\n function(/** @type {Error | null} */ err, /** @type {Node[]} */ result) {\n if (err) {\n decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));\n }\n if (result) {\n decl.value = result[0];\n /** @type {Declaration & { important?: string }} */ (decl).important = /** @type {string} */ (/** @type {unknown} */ (result[1])) || '';\n decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));\n }\n });\n } else {\n decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));\n }\n\n return decl;\n }\n else {\n return decl;\n }\n }\n if (!Array.isArray(toParse)) {\n return transformDeclaration.call(self, toParse);\n }\n else {\n /** @type {Declaration[]} */\n const nodes = [];\n for (let ti = 0; ti < toParse.length; ti++) {\n nodes.push(transformDeclaration.call(self, toParse[ti]));\n }\n return nodes;\n }\n }\n\n rulesets() {\n if (!this.rules) { return []; }\n\n /** @type {Node[]} */\n const filtRules = [];\n const rules = this.rules;\n /** @type {number} */\n let i;\n /** @type {Node} */\n let rule;\n\n for (i = 0; (rule = rules[i]); i++) {\n if (/** @type {RuleNode} */ (rule).isRuleset) {\n filtRules.push(rule);\n }\n }\n\n return filtRules;\n }\n\n /** @param {Node} rule */\n prependRule(rule) {\n const rules = this.rules;\n if (rules) {\n rules.unshift(rule);\n } else {\n this.rules = [ rule ];\n }\n this.setParent(rule, this);\n }\n\n /**\n * @param {Selector} selector\n * @param {Ruleset | null} [self]\n * @param {((rule: Node) => boolean)} [filter]\n * @returns {{ rule: Node, path: Node[] }[]}\n */\n find(selector, self, filter) {\n self = self || this;\n /** @type {{ rule: Node, path: Node[] }[]} */\n const rules = [];\n /** @type {number | undefined} */\n let match;\n /** @type {{ rule: Node, path: Node[] }[]} */\n let foundMixins;\n const key = selector.toCSS(/** @type {EvalContext} */ ({}));\n\n if (key in this._lookups) { return /** @type {{ rule: Node, path: Node[] }[]} */ (this._lookups[key]); }\n\n this.rulesets().forEach(function (rule) {\n if (rule !== self) {\n for (let j = 0; j < /** @type {RuleNode} */ (rule).selectors.length; j++) {\n match = selector.match(/** @type {RuleNode} */ (rule).selectors[j]);\n if (match) {\n if (selector.elements.length > match) {\n if (!filter || filter(rule)) {\n foundMixins = /** @type {Ruleset} */ (/** @type {unknown} */ (rule)).find(new Selector(selector.elements.slice(match)), self, filter);\n for (let i = 0; i < foundMixins.length; ++i) {\n foundMixins[i].path.push(rule);\n }\n Array.prototype.push.apply(rules, foundMixins);\n }\n } else {\n rules.push({ rule, path: []});\n }\n break;\n }\n }\n }\n });\n this._lookups[key] = rules;\n return rules;\n }\n\n /**\n * @param {EvalContext} context\n * @param {CSSOutput} output\n */\n genCSS(context, output) {\n /** @type {number} */\n let i;\n /** @type {number} */\n let j;\n /** @type {Node[]} */\n const charsetRuleNodes = [];\n /** @type {Node[]} */\n let ruleNodes = [];\n\n let // Line number debugging\n debugInfo;\n\n /** @type {Node} */\n let rule;\n /** @type {Selector[]} */\n let path;\n\n context.tabLevel = (context.tabLevel || 0);\n\n if (!this.root) {\n context.tabLevel++;\n }\n\n const tabRuleStr = context.compress ? '' : Array(context.tabLevel + 1).join(' ');\n const tabSetStr = context.compress ? '' : Array(context.tabLevel).join(' ');\n /** @type {string} */\n let sep;\n\n let charsetNodeIndex = 0;\n let importNodeIndex = 0;\n for (i = 0; (rule = /** @type {Node[]} */ (this.rules)[i]); i++) {\n if (rule instanceof Comment) {\n if (importNodeIndex === i) {\n importNodeIndex++;\n }\n ruleNodes.push(rule);\n } else if (/** @type {RuleNode} */ (rule).isCharset && /** @type {RuleNode} */ (rule).isCharset()) {\n ruleNodes.splice(charsetNodeIndex, 0, rule);\n charsetNodeIndex++;\n importNodeIndex++;\n } else if (rule.type === 'Import') {\n ruleNodes.splice(importNodeIndex, 0, rule);\n importNodeIndex++;\n } else {\n ruleNodes.push(rule);\n }\n }\n ruleNodes = charsetRuleNodes.concat(ruleNodes);\n\n // If this is the root node, we don't render\n // a selector, or {}.\n if (!this.root) {\n debugInfo = getDebugInfo(context, /** @type {{ debugInfo: { lineNumber: number, fileName: string } }} */ (/** @type {unknown} */ (this)), tabSetStr);\n\n if (debugInfo) {\n output.add(debugInfo);\n output.add(tabSetStr);\n }\n\n const paths = /** @type {Selector[][]} */ (this.paths);\n const pathCnt = paths.length;\n /** @type {number} */\n let pathSubCnt;\n\n sep = context.compress ? ',' : (`,\\n${tabSetStr}`);\n\n for (i = 0; i < pathCnt; i++) {\n path = paths[i];\n if (!(pathSubCnt = path.length)) { continue; }\n if (i > 0) { output.add(sep); }\n\n /** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector = true;\n path[0].genCSS(context, output);\n\n /** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector = false;\n for (j = 1; j < pathSubCnt; j++) {\n path[j].genCSS(context, output);\n }\n }\n\n output.add((context.compress ? '{' : ' {\\n') + tabRuleStr);\n }\n\n // Compile rules and rulesets\n for (i = 0; (rule = ruleNodes[i]); i++) {\n\n if (i + 1 === ruleNodes.length) {\n context.lastRule = true;\n }\n\n const currentLastRule = context.lastRule;\n if (rule.isRulesetLike()) {\n context.lastRule = false;\n }\n\n if (rule.genCSS) {\n rule.genCSS(context, output);\n } else if (rule.value) {\n output.add(/** @type {string} */ (rule.value).toString());\n }\n\n context.lastRule = currentLastRule;\n\n if (!context.lastRule && rule.isVisible()) {\n output.add(context.compress ? '' : (`\\n${tabRuleStr}`));\n } else {\n context.lastRule = false;\n }\n }\n\n if (!this.root) {\n output.add((context.compress ? '}' : `\\n${tabSetStr}}`));\n context.tabLevel--;\n }\n\n if (!output.isEmpty() && !context.compress && this.firstRoot) {\n output.add('\\n');\n }\n }\n\n /**\n * @param {Selector[][]} paths\n * @param {Selector[][]} context\n * @param {Selector[]} selectors\n */\n joinSelectors(paths, context, selectors) {\n for (let s = 0; s < selectors.length; s++) {\n this.joinSelector(paths, context, selectors[s]);\n }\n }\n\n /**\n * @param {Selector[][]} paths\n * @param {Selector[][]} context\n * @param {Selector} selector\n */\n joinSelector(paths, context, selector) {\n\n /**\n * @param {Selector[]} elementsToPak\n * @param {Element} originalElement\n * @returns {Paren}\n */\n function createParenthesis(elementsToPak, originalElement) {\n /** @type {Paren} */\n let replacementParen;\n /** @type {number} */\n let j;\n if (elementsToPak.length === 0) {\n replacementParen = new Paren(elementsToPak[0]);\n } else {\n const insideParent = new Array(elementsToPak.length);\n for (j = 0; j < elementsToPak.length; j++) {\n insideParent[j] = new Element(\n null,\n elementsToPak[j],\n originalElement.isVariable,\n originalElement._index,\n originalElement._fileInfo\n );\n }\n replacementParen = new Paren(new Selector(insideParent));\n }\n return replacementParen;\n }\n\n /**\n * @param {Paren | Selector} containedElement\n * @param {Element} originalElement\n * @returns {Selector}\n */\n function createSelector(containedElement, originalElement) {\n /** @type {Element} */\n let element;\n /** @type {Selector} */\n let selector;\n element = new Element(null, containedElement, originalElement.isVariable, originalElement._index, originalElement._fileInfo);\n selector = new Selector([element]);\n return selector;\n }\n\n /**\n * @param {Selector[]} beginningPath\n * @param {Selector[]} addPath\n * @param {Element} replacedElement\n * @param {Selector} originalSelector\n * @returns {Selector[]}\n */\n function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {\n /** @type {Selector[]} */\n let newSelectorPath;\n /** @type {Selector} */\n let lastSelector;\n /** @type {Selector} */\n let newJoinedSelector;\n // our new selector path\n newSelectorPath = [];\n\n // construct the joined selector - if & is the first thing this will be empty,\n // if not newJoinedSelector will be the last set of elements in the selector\n if (beginningPath.length > 0) {\n newSelectorPath = utils.copyArray(beginningPath);\n lastSelector = newSelectorPath.pop();\n newJoinedSelector = originalSelector.createDerived(utils.copyArray(lastSelector.elements));\n }\n else {\n newJoinedSelector = originalSelector.createDerived([]);\n }\n\n if (addPath.length > 0) {\n // /deep/ is a CSS4 selector - (removed, so should deprecate)\n // that is valid without anything in front of it\n // so if the & does not have a combinator that is \"\" or \" \" then\n // and there is a combinator on the parent, then grab that.\n // this also allows + a { & .b { .a & { ... though not sure why you would want to do that\n let combinator = replacedElement.combinator;\n\n const parentEl = addPath[0].elements[0];\n if (combinator.emptyOrWhitespace && !parentEl.combinator.emptyOrWhitespace) {\n combinator = parentEl.combinator;\n }\n // join the elements so far with the first part of the parent\n newJoinedSelector.elements.push(new Element(\n combinator,\n parentEl.value,\n replacedElement.isVariable,\n replacedElement._index,\n replacedElement._fileInfo\n ));\n newJoinedSelector.elements = newJoinedSelector.elements.concat(addPath[0].elements.slice(1));\n }\n\n // now add the joined selector - but only if it is not empty\n if (newJoinedSelector.elements.length !== 0) {\n newSelectorPath.push(newJoinedSelector);\n }\n\n // put together the parent selectors after the join (e.g. the rest of the parent)\n if (addPath.length > 1) {\n let restOfPath = addPath.slice(1);\n restOfPath = restOfPath.map(function (/** @type {Selector} */ selector) {\n return selector.createDerived(selector.elements, []);\n });\n newSelectorPath = newSelectorPath.concat(restOfPath);\n }\n return newSelectorPath;\n }\n\n /**\n * @param {Selector[][]} beginningPath\n * @param {Selector[]} addPaths\n * @param {Element} replacedElement\n * @param {Selector} originalSelector\n * @param {Selector[][]} result\n * @returns {Selector[][]}\n */\n function addAllReplacementsIntoPath( beginningPath, addPaths, replacedElement, originalSelector, result) {\n /** @type {number} */\n let j;\n for (j = 0; j < beginningPath.length; j++) {\n const newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);\n result.push(newSelectorPath);\n }\n return result;\n }\n\n /**\n * @param {Element[]} elements\n * @param {Selector[][]} selectors\n */\n function mergeElementsOnToSelectors(elements, selectors) {\n /** @type {number} */\n let i;\n /** @type {Selector[]} */\n let sel;\n\n if (elements.length === 0) {\n return ;\n }\n if (selectors.length === 0) {\n selectors.push([ new Selector(elements) ]);\n return;\n }\n\n for (i = 0; (sel = selectors[i]); i++) {\n // if the previous thing in sel is a parent this needs to join on to it\n if (sel.length > 0) {\n sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));\n }\n else {\n sel.push(new Selector(elements));\n }\n }\n }\n\n /**\n * @param {Selector[][]} paths\n * @param {Selector[][]} context\n * @param {Selector} inSelector\n * @returns {boolean}\n */\n function replaceParentSelector(paths, context, inSelector) {\n // The paths are [[Selector]]\n // The first list is a list of comma separated selectors\n // The inner list is a list of inheritance separated selectors\n // e.g.\n // .a, .b {\n // .c {\n // }\n // }\n // == [[.a] [.c]] [[.b] [.c]]\n //\n /** @type {number} */\n let i;\n /** @type {number} */\n let j;\n /** @type {number} */\n let k;\n /** @type {Element[]} */\n let currentElements;\n /** @type {Selector[][]} */\n let newSelectors;\n /** @type {Selector[][]} */\n let selectorsMultiplied;\n /** @type {Selector[]} */\n let sel;\n /** @type {Element} */\n let el;\n let hadParentSelector = false;\n /** @type {number} */\n let length;\n /** @type {Selector} */\n let lastSelector;\n\n /**\n * @param {Element} element\n * @returns {Selector | null}\n */\n function findNestedSelector(element) {\n /** @type {Node} */\n let maybeSelector;\n if (!(element.value instanceof Paren)) {\n return null;\n }\n\n maybeSelector = /** @type {Node} */ (element.value.value);\n if (!(maybeSelector instanceof Selector)) {\n return null;\n }\n\n return maybeSelector;\n }\n\n // the elements from the current selector so far\n currentElements = [];\n // the current list of new selectors to add to the path.\n // We will build it up. We initiate it with one empty selector as we \"multiply\" the new selectors\n // by the parents\n newSelectors = [\n []\n ];\n\n for (i = 0; (el = inSelector.elements[i]); i++) {\n // non parent reference elements just get added\n if (el.value !== '&') {\n const nestedSelector = findNestedSelector(el);\n if (nestedSelector !== null) {\n // merge the current list of non parent selector elements\n // on to the current list of selectors to add\n mergeElementsOnToSelectors(currentElements, newSelectors);\n\n /** @type {Selector[][]} */\n const nestedPaths = [];\n /** @type {boolean | undefined} */\n let replaced;\n /** @type {Selector[][]} */\n const replacedNewSelectors = [];\n\n // Check if this is a comma-separated selector list inside the paren\n // e.g. :not(&.a, &.b) produces Selector([Selector, Anonymous(','), Selector])\n const hasSubSelectors = nestedSelector.elements.some(e => e instanceof Selector);\n\n if (hasSubSelectors) {\n // Process each sub-selector individually\n /** @type {(Element | Selector)[]} */\n const resolvedElements = [];\n for (const subEl of nestedSelector.elements) {\n if (subEl instanceof Selector) {\n /** @type {Selector[][]} */\n const subPaths = [];\n const subReplaced = replaceParentSelector(subPaths, context, subEl);\n replaced = replaced || subReplaced;\n if (subPaths.length > 0 && subPaths[0].length > 0) {\n resolvedElements.push(subPaths[0][0]);\n } else {\n resolvedElements.push(subEl);\n }\n } else {\n resolvedElements.push(subEl);\n }\n }\n hadParentSelector = hadParentSelector || /** @type {boolean} */ (replaced);\n const resolvedNestedSelector = new Selector(resolvedElements);\n const replacementSelector = createSelector(createParenthesis([resolvedNestedSelector], el), el);\n addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);\n } else {\n replaced = replaceParentSelector(nestedPaths, context, nestedSelector);\n hadParentSelector = hadParentSelector || replaced;\n // the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors\n for (k = 0; k < nestedPaths.length; k++) {\n const replacementSelector = createSelector(createParenthesis(nestedPaths[k], el), el);\n addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);\n }\n }\n newSelectors = replacedNewSelectors;\n currentElements = [];\n } else {\n currentElements.push(el);\n }\n\n } else {\n hadParentSelector = true;\n // the new list of selectors to add\n selectorsMultiplied = [];\n\n // merge the current list of non parent selector elements\n // on to the current list of selectors to add\n mergeElementsOnToSelectors(currentElements, newSelectors);\n\n // loop through our current selectors\n for (j = 0; j < newSelectors.length; j++) {\n sel = newSelectors[j];\n // if we don't have any parent paths, the & might be in a mixin so that it can be used\n // whether there are parents or not\n if (context.length === 0) {\n // the combinator used on el should now be applied to the next element instead so that\n // it is not lost\n if (sel.length > 0) {\n sel[0].elements.push(new Element(el.combinator, '', el.isVariable, el._index, el._fileInfo));\n }\n selectorsMultiplied.push(sel);\n }\n else {\n // and the parent selectors\n for (k = 0; k < context.length; k++) {\n // We need to put the current selectors\n // then join the last selector's elements on to the parents selectors\n const newSelectorPath = addReplacementIntoPath(sel, context[k], el, inSelector);\n // add that to our new set of selectors\n selectorsMultiplied.push(newSelectorPath);\n }\n }\n }\n\n // our new selectors has been multiplied, so reset the state\n newSelectors = selectorsMultiplied;\n currentElements = [];\n }\n }\n\n // if we have any elements left over (e.g. .a& .b == .b)\n // add them on to all the current selectors\n mergeElementsOnToSelectors(currentElements, newSelectors);\n\n for (i = 0; i < newSelectors.length; i++) {\n length = newSelectors[i].length;\n if (length > 0) {\n paths.push(newSelectors[i]);\n lastSelector = newSelectors[i][length - 1];\n newSelectors[i][length - 1] = lastSelector.createDerived(lastSelector.elements, inSelector.extendList);\n }\n }\n\n return hadParentSelector;\n }\n\n /**\n * @param {VisibilityInfo} visibilityInfo\n * @param {Selector} deriveFrom\n */\n function deriveSelector(visibilityInfo, deriveFrom) {\n const newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);\n newSelector.copyVisibilityInfo(visibilityInfo);\n return newSelector;\n }\n\n // joinSelector code follows\n /** @type {number} */\n let i;\n /** @type {Selector[][]} */\n let newPaths;\n /** @type {boolean} */\n let hadParentSelector;\n\n newPaths = [];\n hadParentSelector = replaceParentSelector(newPaths, context, selector);\n\n if (!hadParentSelector) {\n if (context.length > 0) {\n newPaths = [];\n for (i = 0; i < context.length; i++) {\n\n const concatenated = context[i].map(deriveSelector.bind(this, selector.visibilityInfo()));\n\n concatenated.push(selector);\n newPaths.push(concatenated);\n }\n }\n else {\n newPaths = [[selector]];\n }\n }\n\n for (i = 0; i < newPaths.length; i++) {\n paths.push(newPaths[i]);\n }\n\n }\n}\n\nexport default Ruleset;\n"
},
{
"path": "packages/less/lib/less/tree/selector.js",
"content": "// @ts-check\nimport Node from './node.js';\nimport Element from './element.js';\nimport LessError from '../less-error.js';\nimport * as utils from '../utils.js';\nimport Parser from '../parser/parser.js';\n\n/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo, TreeVisitor } from './node.js' */\n\nclass Selector extends Node {\n get type() { return 'Selector'; }\n\n /**\n * @param {(Element | Selector)[] | string} [elements]\n * @param {Node[] | null} [extendList]\n * @param {Node | null} [condition]\n * @param {number} [index]\n * @param {FileInfo} [currentFileInfo]\n * @param {VisibilityInfo} [visibilityInfo]\n */\n constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {\n super();\n /** @type {Node[] | null | undefined} */\n this.extendList = extendList;\n /** @type {Node | null | undefined} */\n this.condition = condition;\n /** @type {boolean | Node} */\n this.evaldCondition = !condition;\n this._index = index;\n this._fileInfo = currentFileInfo;\n /** @type {Element[]} */\n this.elements = this.getElements(elements);\n /** @type {string[] | undefined} */\n this.mixinElements_ = undefined;\n /** @type {boolean | undefined} */\n this.mediaEmpty = undefined;\n this.copyVisibilityInfo(visibilityInfo);\n this.setParent(this.elements, this);\n }\n\n /** @param {TreeVisitor} visitor */\n accept(visitor) {\n if (this.elements) {\n this.elements = /** @type {Element[]} */ (visitor.visitArray(this.elements));\n }\n if (this.extendList) {\n this.extendList = visitor.visitArray(this.extendList);\n }\n if (this.condition) {\n this.condition = visitor.visit(this.condition);\n }\n }\n\n /**\n * @param {Element[]} elements\n * @param {Node[] | null} [extendList]\n * @param {boolean | Node} [evaldCondition]\n */\n createDerived(elements, extendList, evaldCondition) {\n elements = this.getElements(elements);\n const newSelector = new Selector(elements, extendList || this.extendList,\n null, this.getIndex(), this.fileInfo(), this.visibilityInfo());\n newSelector.evaldCondition = (!utils.isNullOrUndefined(evaldCondition)) ? evaldCondition : this.evaldCondition;\n newSelector.mediaEmpty = this.mediaEmpty;\n return newSelector;\n }\n\n /**\n * @param {(Element | Selector)[] | string | null | undefined} els\n * @returns {Element[]}\n */\n getElements(els) {\n if (!els) {\n return [new Element('', '&', false, this._index, this._fileInfo)];\n }\n if (typeof els === 'string') {\n const fileInfo = this._fileInfo;\n const parse = this.parse;\n new (/** @type {new (...args: unknown[]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(parse.context, parse.importManager, fileInfo, this._index).parseNode(\n els,\n ['selector'],\n function(/** @type {{ index: number, message: string } | null} */ err, /** @type {Selector[]} */ result) {\n if (err) {\n throw new LessError({\n index: err.index,\n message: err.message\n }, parse.imports, /** @type {string} */ (/** @type {FileInfo} */ (fileInfo).filename));\n }\n els = result[0].elements;\n });\n }\n return /** @type {Element[]} */ (els);\n }\n\n createEmptySelectors() {\n const el = new Element('', '&', false, this._index, this._fileInfo), sels = [new Selector([el], null, null, this._index, this._fileInfo)];\n sels[0].mediaEmpty = true;\n return sels;\n }\n\n /**\n * @param {Selector} other\n * @returns {number}\n */\n match(other) {\n const elements = this.elements;\n const len = elements.length;\n let olen;\n let i;\n\n /** @type {string[]} */\n const mixinEls = other.mixinElements();\n olen = mixinEls.length;\n if (olen === 0 || len < olen) {\n return 0;\n } else {\n for (i = 0; i < olen; i++) {\n if (elements[i].value !== mixinEls[i]) {\n return 0;\n }\n }\n }\n\n return olen; // return number of matched elements\n }\n\n /** @returns {string[]} */\n mixinElements() {\n if (this.mixinElements_) {\n return this.mixinElements_;\n }\n\n /** @type {string[] | null} */\n let elements = this.elements.map( function(v) {\n return /** @type {string} */ (v.combinator.value) + (/** @type {{ value: string }} */ (v.value).value || v.value);\n }).join('').match(/[,&#*.\\w-]([\\w-]|(\\\\.))*/g);\n\n if (elements) {\n if (elements[0] === '&') {\n elements.shift();\n }\n } else {\n elements = [];\n }\n\n return (this.mixinElements_ = elements);\n }\n\n isJustParentSelector() {\n return !this.mediaEmpty &&\n this.elements.length === 1 &&\n this.elements[0].value === '&' &&\n (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');\n }\n\n /** @param {EvalContext} context */\n eval(context) {\n const evaldCondition = this.condition && this.condition.eval(context);\n let elements = this.elements;\n /** @type {Node[] | null | undefined} */\n let extendList = this.extendList;\n\n if (elements) {\n const evaldElements = new Array(elements.length);\n for (let i = 0; i < elements.length; i++) {\n evaldElements[i] = elements[i].eval(context);\n }\n elements = evaldElements;\n }\n if (extendList) {\n const evaldExtends = new Array(extendList.length);\n for (let i = 0; i < extendList.length; i++) {\n evaldExtends[i] = extendList[i].eval(context);\n }\n extendList = evaldExtends;\n }\n\n return this.createDerived(elements, extendList, evaldCondition);\n }\n\n /**\n * @param {EvalContext} context\n * @param {CSSOutput} output\n */\n genCSS(context, output) {\n let i, element;\n if ((!context || !/** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector) && this.elements[0].combinator.value === '') {\n output.add(' ', this.fileInfo(), this.getIndex());\n }\n for (i = 0; i < this.elements.length; i++) {\n element = this.elements[i];\n element.genCSS(context, output);\n }\n }\n\n getIsOutput() {\n return this.evaldCondition;\n }\n}\n\nexport default Selector;\n"
},
{
"path": "packages/less/lib/less/tree/unicode-descriptor.js",
"content": "// @ts-check\nimport Node from './node.js';\n\nclass UnicodeDescriptor extends Node {\n get type() { return 'UnicodeDescriptor'; }\n\n /** @param {string} value */\n constructor(value) {\n super();\n this.value = value;\n }\n}\n\nexport default UnicodeDescriptor;\n"
},
{
"path": "packages/less/lib/less/tree/unit.js",
"content": "// @ts-check\nimport Node from './node.js';\nimport unitConversions from '../data/unit-conversions.js';\nimport * as utils from '../utils.js';\n\n/** @import { EvalContext, CSSOutput } from './node.js' */\n\nclass Unit extends Node {\n get type() { return 'Unit'; }\n\n /**\n * @param {string[]} [numerator]\n * @param {string[]} [denominator]\n * @param {string} [backupUnit]\n */\n constructor(numerator, denominator, backupUnit) {\n super();\n /** @type {string[]} */\n this.numerator = numerator ? utils.copyArray(numerator).sort() : [];\n /** @type {string[]} */\n this.denominator = denominator ? utils.copyArray(denominator).sort() : [];\n if (backupUnit) {\n /** @type {string | undefined} */\n this.backupUnit = backupUnit;\n } else if (numerator && numerator.length) {\n this.backupUnit = numerator[0];\n }\n }\n\n clone() {\n return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);\n }\n\n /**\n * @param {EvalContext} context\n * @param {CSSOutput} output\n */\n genCSS(context, output) {\n // Dimension checks the unit is singular and throws an error if in strict math mode.\n const strictUnits = context && context.strictUnits;\n if (this.numerator.length === 1) {\n output.add(this.numerator[0]); // the ideal situation\n } else if (!strictUnits && this.backupUnit) {\n output.add(this.backupUnit);\n } else if (!strictUnits && this.denominator.length) {\n output.add(this.denominator[0]);\n }\n }\n\n toString() {\n let i, returnStr = this.numerator.join('*');\n for (i = 0; i < this.denominator.length; i++) {\n returnStr += `/${this.denominator[i]}`;\n }\n return returnStr;\n }\n\n /**\n * @param {Unit} other\n * @returns {0 | undefined}\n */\n compare(other) {\n return this.is(other.toString()) ? 0 : undefined;\n }\n\n /** @param {string} unitString */\n is(unitString) {\n return this.toString().toUpperCase() === unitString.toUpperCase();\n }\n\n isLength() {\n 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} */ ({})));\n }\n\n isEmpty() {\n return this.numerator.length === 0 && this.denominator.length === 0;\n }\n\n isSingular() {\n return this.numerator.length <= 1 && this.denominator.length === 0;\n }\n\n /** @param {(atomicUnit: string, denominator: boolean) => string} callback */\n map(callback) {\n let i;\n\n for (i = 0; i < this.numerator.length; i++) {\n this.numerator[i] = callback(this.numerator[i], false);\n }\n\n for (i = 0; i < this.denominator.length; i++) {\n this.denominator[i] = callback(this.denominator[i], true);\n }\n }\n\n /** @returns {{ [groupName: string]: string }} */\n usedUnits() {\n /** @type {{ [unitName: string]: number }} */\n let group;\n /** @type {{ [groupName: string]: string }} */\n const result = {};\n /** @type {(atomicUnit: string) => string} */\n let mapUnit;\n /** @type {string} */\n let groupName;\n\n mapUnit = function (atomicUnit) {\n // eslint-disable-next-line no-prototype-builtins\n if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {\n result[groupName] = atomicUnit;\n }\n\n return atomicUnit;\n };\n\n for (groupName in unitConversions) {\n // eslint-disable-next-line no-prototype-builtins\n if (unitConversions.hasOwnProperty(groupName)) {\n group = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);\n\n this.map(mapUnit);\n }\n }\n\n return result;\n }\n\n cancel() {\n /** @type {{ [unit: string]: number }} */\n const counter = {};\n /** @type {string} */\n let atomicUnit;\n let i;\n\n for (i = 0; i < this.numerator.length; i++) {\n atomicUnit = this.numerator[i];\n counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;\n }\n\n for (i = 0; i < this.denominator.length; i++) {\n atomicUnit = this.denominator[i];\n counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;\n }\n\n this.numerator = [];\n this.denominator = [];\n\n for (atomicUnit in counter) {\n // eslint-disable-next-line no-prototype-builtins\n if (counter.hasOwnProperty(atomicUnit)) {\n const count = counter[atomicUnit];\n\n if (count > 0) {\n for (i = 0; i < count; i++) {\n this.numerator.push(atomicUnit);\n }\n } else if (count < 0) {\n for (i = 0; i < -count; i++) {\n this.denominator.push(atomicUnit);\n }\n }\n }\n }\n\n this.numerator.sort();\n this.denominator.sort();\n }\n}\n\nexport default Unit;\n"
},
{
"path": "packages/less/lib/less/tree/url.js",
"content": "// @ts-check\n/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo } from './node.js' */\nimport Node from './node.js';\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction escapePath(path) {\n return path.replace(/[()'\"\\s]/g, function(match) { return `\\\\${match}`; });\n}\n\nclass URL extends Node {\n get type() { return 'Url'; }\n\n /**\n * @param {Node} val\n * @param {number} index\n * @param {FileInfo} currentFileInfo\n * @param {boolean} [isEvald]\n */\n constructor(val, index, currentFileInfo, isEvald) {\n super();\n this.value = val;\n this._index = index;\n this._fileInfo = currentFileInfo;\n /** @type {boolean | undefined} */\n this.isEvald = isEvald;\n }\n\n /** @param {TreeVisitor} visitor */\n accept(visitor) {\n this.value = visitor.visit(/** @type {Node} */ (this.value));\n }\n\n /**\n * @param {EvalContext} context\n * @param {CSSOutput} output\n */\n genCSS(context, output) {\n output.add('url(');\n /** @type {Node} */ (this.value).genCSS(context, output);\n output.add(')');\n }\n\n /** @param {EvalContext} context */\n eval(context) {\n const val = /** @type {Node} */ (this.value).eval(context);\n let rootpath;\n\n if (!this.isEvald) {\n // Add the rootpath if the URL requires a rewrite\n rootpath = this.fileInfo() && this.fileInfo().rootpath;\n if (typeof rootpath === 'string' &&\n typeof val.value === 'string' &&\n context.pathRequiresRewrite(/** @type {string} */ (val.value))) {\n if (!/** @type {import('./quoted.js').default} */ (val).quote) {\n rootpath = escapePath(rootpath);\n }\n val.value = context.rewritePath(/** @type {string} */ (val.value), rootpath);\n } else {\n val.value = context.normalizePath(/** @type {string} */ (val.value));\n }\n\n // Add url args if enabled\n if (context.urlArgs) {\n if (!/** @type {string} */ (val.value).match(/^\\s*data:/)) {\n const delimiter = /** @type {string} */ (val.value).indexOf('?') === -1 ? '?' : '&';\n const urlArgs = delimiter + context.urlArgs;\n if (/** @type {string} */ (val.value).indexOf('#') !== -1) {\n val.value = /** @type {string} */ (val.value).replace('#', `${urlArgs}#`);\n } else {\n val.value += urlArgs;\n }\n }\n }\n }\n\n return new URL(val, this.getIndex(), this.fileInfo(), true);\n }\n}\n\nexport default URL;\n"
},
{
"path": "packages/less/lib/less/tree/value.js",
"content": "// @ts-check\n/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */\nimport Node from './node.js';\n\nclass Value extends Node {\n get type() { return 'Value'; }\n\n /** @param {Node[] | Node} value */\n constructor(value) {\n super();\n if (!value) {\n throw new Error('Value requires an array argument');\n }\n if (!Array.isArray(value)) {\n this.value = [ value ];\n }\n else {\n this.value = value;\n }\n }\n\n /** @param {TreeVisitor} visitor */\n accept(visitor) {\n if (this.value) {\n this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));\n }\n }\n\n /**\n * @param {EvalContext} context\n * @returns {Node}\n */\n eval(context) {\n const value = /** @type {Node[]} */ (this.value);\n if (value.length === 1) {\n return value[0].eval(context);\n } else {\n return new Value(value.map(function (v) {\n return v.eval(context);\n }));\n }\n }\n\n /**\n * @param {EvalContext} context\n * @param {CSSOutput} output\n */\n genCSS(context, output) {\n const value = /** @type {Node[]} */ (this.value);\n let i;\n for (i = 0; i < value.length; i++) {\n value[i].genCSS(context, output);\n if (i + 1 < value.length) {\n output.add((context && context.compress) ? ',' : ', ');\n }\n }\n }\n}\n\nexport default Value;\n"
},
{
"path": "packages/less/lib/less/tree/variable-call.js",
"content": "// @ts-check\n/** @import { EvalContext, FileInfo } from './node.js' */\nimport Node from './node.js';\nimport Variable from './variable.js';\nimport Ruleset from './ruleset.js';\nimport DetachedRuleset from './detached-ruleset.js';\nimport LessError from '../less-error.js';\n\nclass VariableCall extends Node {\n get type() { return 'VariableCall'; }\n\n /**\n * @param {string} variable\n * @param {number} index\n * @param {FileInfo} currentFileInfo\n */\n constructor(variable, index, currentFileInfo) {\n super();\n this.variable = variable;\n this._index = index;\n this._fileInfo = currentFileInfo;\n this.allowRoot = true;\n }\n\n /**\n * @param {EvalContext} context\n * @returns {Node}\n */\n eval(context) {\n let rules;\n /** @type {DetachedRuleset | Node} */\n let detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);\n const error = new LessError({message: `Could not evaluate variable call ${this.variable}`});\n\n if (!(/** @type {DetachedRuleset} */ (detachedRuleset)).ruleset) {\n const dr = /** @type {Node & { rules?: Node[] }} */ (detachedRuleset);\n if (dr.rules) {\n rules = detachedRuleset;\n }\n else if (Array.isArray(detachedRuleset)) {\n rules = new Ruleset(null, detachedRuleset);\n }\n else if (Array.isArray(detachedRuleset.value)) {\n rules = new Ruleset(null, detachedRuleset.value);\n }\n else {\n throw error;\n }\n detachedRuleset = new DetachedRuleset(rules);\n }\n\n const dr = /** @type {DetachedRuleset} */ (detachedRuleset);\n if (dr.ruleset) {\n return dr.callEval(context);\n }\n throw error;\n }\n}\n\nexport default VariableCall;\n"
},
{
"path": "packages/less/lib/less/tree/variable.js",
"content": "// @ts-check\n/** @import { EvalContext, FileInfo } from './node.js' */\nimport Node from './node.js';\nimport Call from './call.js';\nimport Ruleset from './ruleset.js';\n\nclass Variable extends Node {\n get type() { return 'Variable'; }\n\n /**\n * @param {string} name\n * @param {number} [index]\n * @param {FileInfo} [currentFileInfo]\n */\n constructor(name, index, currentFileInfo) {\n super();\n this.name = name;\n this._index = index;\n this._fileInfo = currentFileInfo;\n /** @type {boolean | undefined} */\n this.evaluating = undefined;\n }\n\n /**\n * @param {EvalContext} context\n * @returns {Node}\n */\n eval(context) {\n let variable, name = this.name;\n\n if (name.indexOf('@@') === 0) {\n name = `@${new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value}`;\n }\n\n if (this.evaluating) {\n throw { type: 'Name',\n message: `Recursive variable definition for ${name}`,\n filename: this.fileInfo().filename,\n index: this.getIndex() };\n }\n\n this.evaluating = true;\n\n variable = this.find(context.frames, function (frame) {\n const v = /** @type {Ruleset} */ (frame).variable(name);\n if (v) {\n if (v.important) {\n const importantScope = context.importantScope[context.importantScope.length - 1];\n importantScope.important = v.important;\n }\n // If in calc, wrap vars in a function call to cascade evaluate args first\n if (context.inCalc) {\n return (new Call('_SELF', [v.value], 0, undefined)).eval(context);\n }\n else {\n return v.value.eval(context);\n }\n }\n });\n if (variable) {\n this.evaluating = false;\n return variable;\n } else {\n throw { type: 'Name',\n message: `variable ${name} is undefined`,\n filename: this.fileInfo().filename,\n index: this.getIndex() };\n }\n }\n\n /**\n * @param {Node[]} obj\n * @param {(frame: Node) => Node | undefined} fun\n * @returns {Node | null}\n */\n find(obj, fun) {\n for (let i = 0, r; i < obj.length; i++) {\n r = fun.call(obj, obj[i]);\n if (r) { return r; }\n }\n return null;\n }\n}\n\nexport default Variable;\n"
},
{
"path": "packages/less/lib/less/utils.js",
"content": "/* jshint proto: true */\nimport * as Constants from './constants.js';\nimport { copy } from 'copy-anything';\n\nexport function getLocation(index, inputStream) {\n let n = index + 1;\n let line = null;\n let column = -1;\n\n while (--n >= 0 && inputStream.charAt(n) !== '\\n') {\n column++;\n }\n\n if (typeof index === 'number') {\n line = (inputStream.slice(0, index).match(/\\n/g) || '').length;\n }\n\n return {\n line,\n column\n };\n}\n\nexport function copyArray(arr) {\n let i;\n const length = arr.length;\n const copy = new Array(length);\n\n for (i = 0; i < length; i++) {\n copy[i] = arr[i];\n }\n return copy;\n}\n\nexport function clone(obj) {\n const cloned = {};\n for (const prop in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n cloned[prop] = obj[prop];\n }\n }\n return cloned;\n}\n\nexport function defaults(obj1, obj2) {\n let newObj = obj2 || {};\n if (!obj2._defaults) {\n newObj = {};\n const defaults = copy(obj1);\n newObj._defaults = defaults;\n const cloned = obj2 ? copy(obj2) : {};\n Object.assign(newObj, defaults, cloned);\n }\n return newObj;\n}\n\nexport function copyOptions(obj1, obj2) {\n if (obj2 && obj2._defaults) {\n return obj2;\n }\n const opts = defaults(obj1, obj2);\n if (opts.strictMath) {\n opts.math = Constants.Math.PARENS;\n }\n // Back compat with changed relativeUrls option\n if (opts.relativeUrls) {\n opts.rewriteUrls = Constants.RewriteUrls.ALL;\n }\n if (typeof opts.math === 'string') {\n switch (opts.math.toLowerCase()) {\n case 'always':\n opts.math = Constants.Math.ALWAYS;\n break;\n case 'parens-division':\n opts.math = Constants.Math.PARENS_DIVISION;\n break;\n case 'strict':\n case 'parens':\n opts.math = Constants.Math.PARENS;\n break;\n default:\n opts.math = Constants.Math.PARENS;\n }\n }\n if (typeof opts.rewriteUrls === 'string') {\n switch (opts.rewriteUrls.toLowerCase()) {\n case 'off':\n opts.rewriteUrls = Constants.RewriteUrls.OFF;\n break;\n case 'local':\n opts.rewriteUrls = Constants.RewriteUrls.LOCAL;\n break;\n case 'all':\n opts.rewriteUrls = Constants.RewriteUrls.ALL;\n break;\n }\n }\n return opts;\n}\n\nexport function merge(obj1, obj2) {\n for (const prop in obj2) {\n if (Object.prototype.hasOwnProperty.call(obj2, prop)) {\n obj1[prop] = obj2[prop];\n }\n }\n return obj1;\n}\n\nexport function flattenArray(arr, result = []) {\n for (let i = 0, length = arr.length; i < length; i++) {\n const value = arr[i];\n if (Array.isArray(value)) {\n flattenArray(value, result);\n } else {\n if (value !== undefined) {\n result.push(value);\n }\n }\n }\n return result;\n}\n\nexport function isNullOrUndefined(val) {\n return val === null || val === undefined\n}"
},
{
"path": "packages/less/lib/less/visitors/extend-visitor.js",
"content": "/* eslint-disable no-unused-vars */\n/**\n * @todo - Remove unused when JSDoc types are added for visitor methods\n */\nimport tree from '../tree/index.js';\nimport Visitor from './visitor.js';\nimport logger from '../logger.js';\nimport * as utils from '../utils.js';\n\n/* jshint loopfunc:true */\n\nclass ExtendFinderVisitor {\n constructor() {\n this._visitor = new Visitor(this);\n this.contexts = [];\n this.allExtendsStack = [[]];\n }\n\n run(root) {\n root = this._visitor.visit(root);\n root.allExtends = this.allExtendsStack[0];\n return root;\n }\n\n visitDeclaration(declNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitMixinDefinition(mixinDefinitionNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitRuleset(rulesetNode, visitArgs) {\n if (rulesetNode.root) {\n return;\n }\n\n let i;\n let j;\n let extend;\n const allSelectorsExtendList = [];\n let extendList;\n\n // get &:extend(.a); rules which apply to all selectors in this ruleset\n const rules = rulesetNode.rules, ruleCnt = rules ? rules.length : 0;\n for (i = 0; i < ruleCnt; i++) {\n if (rulesetNode.rules[i] instanceof tree.Extend) {\n allSelectorsExtendList.push(rules[i]);\n rulesetNode.extendOnEveryPath = true;\n }\n }\n\n // now find every selector and apply the extends that apply to all extends\n // and the ones which apply to an individual extend\n const paths = rulesetNode.paths;\n for (i = 0; i < paths.length; i++) {\n const selectorPath = paths[i], selector = selectorPath[selectorPath.length - 1], selExtendList = selector.extendList;\n\n extendList = selExtendList ? utils.copyArray(selExtendList).concat(allSelectorsExtendList)\n : allSelectorsExtendList;\n\n if (extendList) {\n extendList = extendList.map(function(allSelectorsExtend) {\n return allSelectorsExtend.clone();\n });\n }\n\n for (j = 0; j < extendList.length; j++) {\n this.foundExtends = true;\n extend = extendList[j];\n extend.findSelfSelectors(selectorPath);\n extend.ruleset = rulesetNode;\n if (j === 0) { extend.firstExtendOnThisSelectorPath = true; }\n this.allExtendsStack[this.allExtendsStack.length - 1].push(extend);\n }\n }\n\n this.contexts.push(rulesetNode.selectors);\n }\n\n visitRulesetOut(rulesetNode) {\n if (!rulesetNode.root) {\n this.contexts.length = this.contexts.length - 1;\n }\n }\n\n visitMedia(mediaNode, visitArgs) {\n mediaNode.allExtends = [];\n this.allExtendsStack.push(mediaNode.allExtends);\n }\n\n visitMediaOut(mediaNode) {\n this.allExtendsStack.length = this.allExtendsStack.length - 1;\n }\n\n visitAtRule(atRuleNode, visitArgs) {\n atRuleNode.allExtends = [];\n this.allExtendsStack.push(atRuleNode.allExtends);\n }\n\n visitAtRuleOut(atRuleNode) {\n this.allExtendsStack.length = this.allExtendsStack.length - 1;\n }\n}\n\nclass ProcessExtendsVisitor {\n constructor() {\n this._visitor = new Visitor(this);\n }\n\n run(root) {\n const extendFinder = new ExtendFinderVisitor();\n this.extendIndices = {};\n extendFinder.run(root);\n if (!extendFinder.foundExtends) { return root; }\n root.allExtends = root.allExtends.concat(this.doExtendChaining(root.allExtends, root.allExtends));\n this.allExtendsStack = [root.allExtends];\n const newRoot = this._visitor.visit(root);\n this.checkExtendsForNonMatched(root.allExtends);\n return newRoot;\n }\n\n checkExtendsForNonMatched(extendList) {\n const indices = this.extendIndices;\n extendList.filter(function(extend) {\n return !extend.hasFoundMatches && extend.parent_ids.length == 1;\n }).forEach(function(extend) {\n let selector = '_unknown_';\n try {\n selector = extend.selector.toCSS({});\n }\n catch (_) {}\n\n if (!indices[`${extend.index} ${selector}`]) {\n indices[`${extend.index} ${selector}`] = true;\n /**\n * @todo Shouldn't this be an error? To alert the developer\n * that they may have made an error in the selector they are\n * targeting?\n */\n logger.warn(`WARNING: extend '${selector}' has no matches`);\n }\n });\n }\n\n doExtendChaining(extendsList, extendsListTarget, iterationCount) {\n //\n // chaining is different from normal extension.. if we extend an extend then we are not just copying, altering\n // and pasting the selector we would do normally, but we are also adding an extend with the same target selector\n // this means this new extend can then go and alter other extends\n //\n // this method deals with all the chaining work - without it, extend is flat and doesn't work on other extend selectors\n // this is also the most expensive.. and a match on one selector can cause an extension of a selector we had already\n // processed if we look at each selector at a time, as is done in visitRuleset\n\n let extendIndex;\n\n let targetExtendIndex;\n let matches;\n const extendsToAdd = [];\n let newSelector;\n const extendVisitor = this;\n let selectorPath;\n let extend;\n let targetExtend;\n let newExtend;\n\n iterationCount = iterationCount || 0;\n\n // loop through comparing every extend with every target extend.\n // a target extend is the one on the ruleset we are looking at copy/edit/pasting in place\n // e.g. .a:extend(.b) {} and .b:extend(.c) {} then the first extend extends the second one\n // and the second is the target.\n // the separation into two lists allows us to process a subset of chains with a bigger set, as is the\n // case when processing media queries\n for (extendIndex = 0; extendIndex < extendsList.length; extendIndex++) {\n for (targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++) {\n\n extend = extendsList[extendIndex];\n targetExtend = extendsListTarget[targetExtendIndex];\n\n // look for circular references\n if ( extend.parent_ids.indexOf( targetExtend.object_id ) >= 0 ) { continue; }\n\n // find a match in the target extends self selector (the bit before :extend)\n selectorPath = [targetExtend.selfSelectors[0]];\n matches = extendVisitor.findMatch(extend, selectorPath);\n\n if (matches.length) {\n extend.hasFoundMatches = true;\n\n // we found a match, so for each self selector..\n extend.selfSelectors.forEach(function(selfSelector) {\n const info = targetExtend.visibilityInfo();\n\n // process the extend as usual\n newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector, extend.isVisible());\n\n // but now we create a new extend from it\n newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0, targetExtend.fileInfo(), info);\n newExtend.selfSelectors = newSelector;\n\n // add the extend onto the list of extends for that selector\n newSelector[newSelector.length - 1].extendList = [newExtend];\n\n // record that we need to add it.\n extendsToAdd.push(newExtend);\n newExtend.ruleset = targetExtend.ruleset;\n\n // remember its parents for circular references\n newExtend.parent_ids = newExtend.parent_ids.concat(targetExtend.parent_ids, extend.parent_ids);\n\n // only process the selector once.. if we have :extend(.a,.b) then multiple\n // extends will look at the same selector path, so when extending\n // we know that any others will be duplicates in terms of what is added to the css\n if (targetExtend.firstExtendOnThisSelectorPath) {\n newExtend.firstExtendOnThisSelectorPath = true;\n targetExtend.ruleset.paths.push(newSelector);\n }\n });\n }\n }\n }\n\n if (extendsToAdd.length) {\n // try to detect circular references to stop a stack overflow.\n // may no longer be needed.\n this.extendChainCount++;\n if (iterationCount > 100) {\n let selectorOne = '{unable to calculate}';\n let selectorTwo = '{unable to calculate}';\n try {\n selectorOne = extendsToAdd[0].selfSelectors[0].toCSS();\n selectorTwo = extendsToAdd[0].selector.toCSS();\n }\n catch (e) {}\n throw { message: `extend circular reference detected. One of the circular extends is currently:${selectorOne}:extend(${selectorTwo})`};\n }\n\n // now process the new extends on the existing rules so that we can handle a extending b extending c extending\n // d extending e...\n return extendsToAdd.concat(extendVisitor.doExtendChaining(extendsToAdd, extendsListTarget, iterationCount + 1));\n } else {\n return extendsToAdd;\n }\n }\n\n visitDeclaration(ruleNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitMixinDefinition(mixinDefinitionNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitSelector(selectorNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitRuleset(rulesetNode, visitArgs) {\n if (rulesetNode.root) {\n return;\n }\n let matches;\n const allExtends = this.allExtendsStack[this.allExtendsStack.length - 1];\n const selectorsToAdd = [];\n const paths = rulesetNode.paths;\n const pathCount = paths.length;\n\n // look at each selector path in the ruleset, find any extend matches and then copy, find and replace\n\n for (let extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {\n const extend = allExtends[extendIndex];\n for (let pathIndex = 0; pathIndex < pathCount; pathIndex++) {\n const selectorPath = paths[pathIndex];\n\n // extending extends happens initially, before the main pass\n if (rulesetNode.extendOnEveryPath) { continue; }\n const extendList = selectorPath[selectorPath.length - 1].extendList;\n if (extendList && extendList.length) { continue; }\n\n matches = this.findMatch(extend, selectorPath);\n\n if (matches.length) {\n extend.hasFoundMatches = true;\n\n const selfSelectors = extend.selfSelectors;\n const isVisible = extend.isVisible();\n for (let si = 0; si < selfSelectors.length; si++) {\n selectorsToAdd.push(this.extendSelector(matches, selectorPath, selfSelectors[si], isVisible));\n }\n }\n }\n }\n rulesetNode.paths = paths.concat(selectorsToAdd);\n }\n\n findMatch(extend, haystackSelectorPath) {\n //\n // look through the haystack selector path to try and find the needle - extend.selector\n // returns an array of selector matches that can then be replaced\n //\n let haystackSelectorIndex;\n\n let hackstackSelector;\n let hackstackElementIndex;\n let haystackElement;\n let targetCombinator;\n let i;\n const needleElements = extend.selector.elements;\n const potentialMatches = [];\n let potentialMatch;\n const matches = [];\n\n // loop through the haystack elements\n for (haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {\n hackstackSelector = haystackSelectorPath[haystackSelectorIndex];\n\n for (hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {\n\n haystackElement = hackstackSelector.elements[hackstackElementIndex];\n\n // if we allow elements before our match we can add a potential match every time. otherwise only at the first element.\n if (extend.allowBefore || (haystackSelectorIndex === 0 && hackstackElementIndex === 0)) {\n potentialMatches.push({pathIndex: haystackSelectorIndex, index: hackstackElementIndex, matched: 0,\n initialCombinator: haystackElement.combinator});\n }\n\n for (i = 0; i < potentialMatches.length; i++) {\n potentialMatch = potentialMatches[i];\n\n // selectors add \" \" onto the first element. When we use & it joins the selectors together, but if we don't\n // then each selector in haystackSelectorPath has a space before it added in the toCSS phase. so we need to\n // work out what the resulting combinator will be\n targetCombinator = haystackElement.combinator.value;\n if (targetCombinator === '' && hackstackElementIndex === 0) {\n targetCombinator = ' ';\n }\n\n // if we don't match, null our match to indicate failure\n if (!this.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) ||\n (potentialMatch.matched > 0 && needleElements[potentialMatch.matched].combinator.value !== targetCombinator)) {\n potentialMatch = null;\n } else {\n potentialMatch.matched++;\n }\n\n // if we are still valid and have finished, test whether we have elements after and whether these are allowed\n if (potentialMatch) {\n potentialMatch.finished = potentialMatch.matched === needleElements.length;\n if (potentialMatch.finished &&\n (!extend.allowAfter &&\n (hackstackElementIndex + 1 < hackstackSelector.elements.length || haystackSelectorIndex + 1 < haystackSelectorPath.length))) {\n potentialMatch = null;\n }\n }\n // if null we remove, if not, we are still valid, so either push as a valid match or continue\n if (potentialMatch) {\n if (potentialMatch.finished) {\n potentialMatch.length = needleElements.length;\n potentialMatch.endPathIndex = haystackSelectorIndex;\n potentialMatch.endPathElementIndex = hackstackElementIndex + 1; // index after end of match\n potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again\n matches.push(potentialMatch);\n }\n } else {\n potentialMatches.splice(i, 1);\n i--;\n }\n }\n }\n }\n return matches;\n }\n\n isElementValuesEqual(elementValue1, elementValue2) {\n if (typeof elementValue1 === 'string' || typeof elementValue2 === 'string') {\n return elementValue1 === elementValue2;\n }\n if (elementValue1 instanceof tree.Attribute) {\n if (elementValue1.op !== elementValue2.op || elementValue1.key !== elementValue2.key) {\n return false;\n }\n if (!elementValue1.value || !elementValue2.value) {\n if (elementValue1.value || elementValue2.value) {\n return false;\n }\n return true;\n }\n elementValue1 = elementValue1.value.value || elementValue1.value;\n elementValue2 = elementValue2.value.value || elementValue2.value;\n return elementValue1 === elementValue2;\n }\n elementValue1 = elementValue1.value;\n elementValue2 = elementValue2.value;\n if (elementValue1 instanceof tree.Selector) {\n if (!(elementValue2 instanceof tree.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {\n return false;\n }\n for (let i = 0; i < elementValue1.elements.length; i++) {\n if (elementValue1.elements[i].combinator.value !== elementValue2.elements[i].combinator.value) {\n if (i !== 0 || (elementValue1.elements[i].combinator.value || ' ') !== (elementValue2.elements[i].combinator.value || ' ')) {\n return false;\n }\n }\n if (!this.isElementValuesEqual(elementValue1.elements[i].value, elementValue2.elements[i].value)) {\n return false;\n }\n }\n return true;\n }\n return false;\n }\n\n extendSelector(matches, selectorPath, replacementSelector, isVisible) {\n\n // for a set of matches, replace each match with the replacement selector\n\n let currentSelectorPathIndex = 0, currentSelectorPathElementIndex = 0, path = [], matchIndex, selector, firstElement, match, newElements;\n\n for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {\n match = matches[matchIndex];\n selector = selectorPath[match.pathIndex];\n firstElement = new tree.Element(\n match.initialCombinator,\n replacementSelector.elements[0].value,\n replacementSelector.elements[0].isVariable,\n replacementSelector.elements[0].getIndex(),\n replacementSelector.elements[0].fileInfo()\n );\n\n if (match.pathIndex > currentSelectorPathIndex && currentSelectorPathElementIndex > 0) {\n path[path.length - 1].elements = path[path.length - 1]\n .elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));\n currentSelectorPathElementIndex = 0;\n currentSelectorPathIndex++;\n }\n\n newElements = selector.elements\n .slice(currentSelectorPathElementIndex, match.index)\n .concat([firstElement])\n .concat(replacementSelector.elements.slice(1));\n\n if (currentSelectorPathIndex === match.pathIndex && matchIndex > 0) {\n path[path.length - 1].elements =\n path[path.length - 1].elements.concat(newElements);\n } else {\n path = path.concat(selectorPath.slice(currentSelectorPathIndex, match.pathIndex));\n\n path.push(new tree.Selector(\n newElements\n ));\n }\n currentSelectorPathIndex = match.endPathIndex;\n currentSelectorPathElementIndex = match.endPathElementIndex;\n if (currentSelectorPathElementIndex >= selectorPath[currentSelectorPathIndex].elements.length) {\n currentSelectorPathElementIndex = 0;\n currentSelectorPathIndex++;\n }\n }\n\n if (currentSelectorPathIndex < selectorPath.length && currentSelectorPathElementIndex > 0) {\n path[path.length - 1].elements = path[path.length - 1]\n .elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));\n currentSelectorPathIndex++;\n }\n\n path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));\n path = path.map(function (currentValue) {\n // we can re-use elements here, because the visibility property matters only for selectors\n const derived = currentValue.createDerived(currentValue.elements);\n if (isVisible) {\n derived.ensureVisibility();\n } else {\n derived.ensureInvisibility();\n }\n return derived;\n });\n return path;\n }\n\n visitMedia(mediaNode, visitArgs) {\n let newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);\n newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));\n this.allExtendsStack.push(newAllExtends);\n }\n\n visitMediaOut(mediaNode) {\n const lastIndex = this.allExtendsStack.length - 1;\n this.allExtendsStack.length = lastIndex;\n }\n\n visitAtRule(atRuleNode, visitArgs) {\n let newAllExtends = atRuleNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);\n newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, atRuleNode.allExtends));\n this.allExtendsStack.push(newAllExtends);\n }\n\n visitAtRuleOut(atRuleNode) {\n const lastIndex = this.allExtendsStack.length - 1;\n this.allExtendsStack.length = lastIndex;\n }\n}\n\nexport default ProcessExtendsVisitor;\n"
},
{
"path": "packages/less/lib/less/visitors/import-sequencer.js",
"content": "class ImportSequencer {\n constructor(onSequencerEmpty) {\n this.imports = [];\n this.variableImports = [];\n this._onSequencerEmpty = onSequencerEmpty;\n this._currentDepth = 0;\n }\n\n addImport(callback) {\n const importSequencer = this,\n importItem = {\n callback,\n args: null,\n isReady: false\n };\n this.imports.push(importItem);\n return function() {\n importItem.args = Array.prototype.slice.call(arguments, 0);\n importItem.isReady = true;\n importSequencer.tryRun();\n };\n }\n\n addVariableImport(callback) {\n this.variableImports.push(callback);\n }\n\n tryRun() {\n this._currentDepth++;\n try {\n while (true) {\n while (this.imports.length > 0) {\n const importItem = this.imports[0];\n if (!importItem.isReady) {\n return;\n }\n this.imports = this.imports.slice(1);\n importItem.callback.apply(null, importItem.args);\n }\n if (this.variableImports.length === 0) {\n break;\n }\n const variableImport = this.variableImports[0];\n this.variableImports = this.variableImports.slice(1);\n variableImport();\n }\n } finally {\n this._currentDepth--;\n }\n if (this._currentDepth === 0 && this._onSequencerEmpty) {\n this._onSequencerEmpty();\n }\n }\n}\n\nexport default ImportSequencer;\n"
},
{
"path": "packages/less/lib/less/visitors/import-visitor.js",
"content": "/* eslint-disable no-unused-vars */\n/**\n * @todo - Remove unused when JSDoc types are added for visitor methods\n */\nimport contexts from '../contexts.js';\nimport Visitor from './visitor.js';\nimport ImportSequencer from './import-sequencer.js';\nimport * as utils from '../utils.js';\n\nconst ImportVisitor = function(importer, finish) {\n\n this._visitor = new Visitor(this);\n this._importer = importer;\n this._finish = finish;\n this.context = new contexts.Eval();\n this.importCount = 0;\n this.onceFileDetectionMap = {};\n this.recursionDetector = {};\n this._sequencer = new ImportSequencer(this._onSequencerEmpty.bind(this));\n};\n\nImportVisitor.prototype = {\n isReplacing: false,\n run: function (root) {\n try {\n // process the contents\n this._visitor.visit(root);\n }\n catch (e) {\n this.error = e;\n }\n\n this.isFinished = true;\n this._sequencer.tryRun();\n },\n _onSequencerEmpty: function() {\n if (!this.isFinished) {\n return;\n }\n this._finish(this.error);\n },\n visitImport: function (importNode, visitArgs) {\n const inlineCSS = importNode.options.inline;\n\n if (!importNode.css || inlineCSS) {\n\n const context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));\n const importParent = context.frames[0];\n\n this.importCount++;\n if (importNode.isVariableImport()) {\n this._sequencer.addVariableImport(this.processImportNode.bind(this, importNode, context, importParent));\n } else {\n this.processImportNode(importNode, context, importParent);\n }\n }\n visitArgs.visitDeeper = false;\n },\n processImportNode: function(importNode, context, importParent) {\n let evaldImportNode;\n const inlineCSS = importNode.options.inline;\n\n try {\n evaldImportNode = importNode.evalForImport(context);\n } catch (e) {\n if (!e.filename) { e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename; }\n // attempt to eval properly and treat as css\n importNode.css = true;\n // if that fails, this error will be thrown\n importNode.error = e;\n }\n\n if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {\n\n if (evaldImportNode.options.multiple) {\n context.importMultiple = true;\n }\n\n // try appending if we haven't determined if it is css or not\n const tryAppendLessExtension = evaldImportNode.css === undefined;\n\n for (let i = 0; i < importParent.rules.length; i++) {\n if (importParent.rules[i] === importNode) {\n importParent.rules[i] = evaldImportNode;\n break;\n }\n }\n\n const onImported = this.onImported.bind(this, evaldImportNode, context), sequencedOnImported = this._sequencer.addImport(onImported);\n\n this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(),\n evaldImportNode.options, sequencedOnImported);\n } else {\n this.importCount--;\n if (this.isFinished) {\n this._sequencer.tryRun();\n }\n }\n },\n onImported: function (importNode, context, e, root, importedAtRoot, fullPath) {\n if (e) {\n if (!e.filename) {\n e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename;\n }\n this.error = e;\n }\n\n const importVisitor = this,\n inlineCSS = importNode.options.inline,\n isPlugin = importNode.options.isPlugin,\n isOptional = importNode.options.optional,\n duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;\n\n if (!context.importMultiple) {\n if (duplicateImport) {\n importNode.skip = true;\n } else {\n importNode.skip = function() {\n if (fullPath in importVisitor.onceFileDetectionMap) {\n return true;\n }\n importVisitor.onceFileDetectionMap[fullPath] = true;\n return false;\n };\n }\n }\n\n if (!fullPath && isOptional) {\n importNode.skip = true;\n }\n\n if (root) {\n importNode.root = root;\n importNode.importedFilename = fullPath;\n\n if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {\n importVisitor.recursionDetector[fullPath] = true;\n\n const oldContext = this.context;\n this.context = context;\n try {\n this._visitor.visit(root);\n } catch (e) {\n this.error = e;\n }\n this.context = oldContext;\n }\n }\n\n importVisitor.importCount--;\n\n if (importVisitor.isFinished) {\n importVisitor._sequencer.tryRun();\n }\n },\n visitDeclaration: function (declNode, visitArgs) {\n if (declNode.value.type === 'DetachedRuleset') {\n this.context.frames.unshift(declNode);\n } else {\n visitArgs.visitDeeper = false;\n }\n },\n visitDeclarationOut: function(declNode) {\n if (declNode.value.type === 'DetachedRuleset') {\n this.context.frames.shift();\n }\n },\n visitAtRule: function (atRuleNode, visitArgs) {\n if (atRuleNode.value) {\n this.context.frames.unshift(atRuleNode);\n } else if (atRuleNode.declarations && atRuleNode.declarations.length) {\n if (atRuleNode.isRooted) {\n this.context.frames.unshift(atRuleNode);\n } else {\n this.context.frames.unshift(atRuleNode.declarations[0]);\n }\n } else if (atRuleNode.rules && atRuleNode.rules.length) {\n this.context.frames.unshift(atRuleNode);\n }\n },\n visitAtRuleOut: function (atRuleNode) {\n this.context.frames.shift();\n },\n visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {\n this.context.frames.unshift(mixinDefinitionNode);\n },\n visitMixinDefinitionOut: function (mixinDefinitionNode) {\n this.context.frames.shift();\n },\n visitRuleset: function (rulesetNode, visitArgs) {\n this.context.frames.unshift(rulesetNode);\n },\n visitRulesetOut: function (rulesetNode) {\n this.context.frames.shift();\n },\n visitMedia: function (mediaNode, visitArgs) {\n this.context.frames.unshift(mediaNode.rules[0]);\n },\n visitMediaOut: function (mediaNode) {\n this.context.frames.shift();\n }\n};\nexport default ImportVisitor;\n"
},
{
"path": "packages/less/lib/less/visitors/index.js",
"content": "import Visitor from './visitor.js';\nimport ImportVisitor from './import-visitor.js';\nimport MarkVisibleSelectorsVisitor from './set-tree-visibility-visitor.js';\nimport ExtendVisitor from './extend-visitor.js';\nimport JoinSelectorVisitor from './join-selector-visitor.js';\nimport ToCSSVisitor from './to-css-visitor.js';\n\nexport default {\n Visitor,\n ImportVisitor,\n MarkVisibleSelectorsVisitor,\n ExtendVisitor,\n JoinSelectorVisitor,\n ToCSSVisitor\n};\n"
},
{
"path": "packages/less/lib/less/visitors/join-selector-visitor.js",
"content": "/* eslint-disable no-unused-vars */\n/**\n * @todo - Remove unused when JSDoc types are added for visitor methods\n */\nimport Visitor from './visitor.js';\n\nclass JoinSelectorVisitor {\n constructor() {\n this.contexts = [[]];\n this._visitor = new Visitor(this);\n }\n\n run(root) {\n return this._visitor.visit(root);\n }\n\n visitDeclaration(declNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitMixinDefinition(mixinDefinitionNode, visitArgs) {\n visitArgs.visitDeeper = false;\n }\n\n visitRuleset(rulesetNode, visitArgs) {\n const context = this.contexts[this.contexts.length - 1];\n const paths = [];\n let selectors;\n\n this.contexts.push(paths);\n\n if (!rulesetNode.root) {\n selectors = rulesetNode.selectors;\n if (selectors) {\n selectors = selectors.filter(function(selector) { return selector.getIsOutput(); });\n rulesetNode.selectors = selectors.length ? selectors : (selectors = null);\n if (selectors) { rulesetNode.joinSelectors(paths, context, selectors); }\n }\n if (!selectors) { rulesetNode.rules = null; }\n rulesetNode.paths = paths;\n }\n }\n\n visitRulesetOut(rulesetNode) {\n this.contexts.length = this.contexts.length - 1;\n }\n\n visitMedia(mediaNode, visitArgs) {\n const context = this.contexts[this.contexts.length - 1];\n mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);\n }\n\n visitAtRule(atRuleNode, visitArgs) {\n const context = this.contexts[this.contexts.length - 1];\n\n if (atRuleNode.declarations && atRuleNode.declarations.length) {\n atRuleNode.declarations[0].root = (context.length === 0 || context[0].multiMedia);\n }\n else if (atRuleNode.rules && atRuleNode.rules.length) {\n atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);\n }\n }\n}\n\nexport default JoinSelectorVisitor;\n"
},
{
"path": "packages/less/lib/less/visitors/set-tree-visibility-visitor.js",
"content": "import Node from '../tree/node.js';\n\nclass SetTreeVisibilityVisitor {\n /** @param {boolean} visible */\n constructor(visible) {\n this.visible = visible;\n }\n\n /** @param {Node} root */\n run(root) {\n this.visit(root);\n }\n\n /**\n * @param {Node[]} nodes\n * @returns {Node[]}\n */\n visitArray(nodes) {\n if (!nodes) {\n return nodes;\n }\n\n const cnt = nodes.length;\n let i;\n for (i = 0; i < cnt; i++) {\n this.visit(nodes[i]);\n }\n return nodes;\n }\n\n /**\n * @param {*} node\n * @returns {*}\n */\n visit(node) {\n if (!node) {\n return node;\n }\n if (node.constructor === Array) {\n return this.visitArray(node);\n }\n\n if (!node.blocksVisibility || node.blocksVisibility()) {\n return node;\n }\n if (this.visible) {\n node.ensureVisibility();\n } else {\n node.ensureInvisibility();\n }\n\n node.accept(this);\n return node;\n }\n}\n\nexport default SetTreeVisibilityVisitor;\n"
},
{
"path": "packages/less/lib/less/visitors/to-css-visitor.js",
"content": "/* eslint-disable no-unused-vars */\n/**\n * @todo - Remove unused when JSDoc types are added for visitor methods\n */\nimport tree from '../tree/index.js';\nimport Visitor from './visitor.js';\nimport mergeRules from '../tree/merge-rules.js';\n\nclass CSSVisitorUtils {\n constructor(context) {\n this._visitor = new Visitor(this);\n this._context = context;\n }\n\n containsSilentNonBlockedChild(bodyRules) {\n let rule;\n if (!bodyRules) {\n return false;\n }\n for (let r = 0; r < bodyRules.length; r++) {\n rule = bodyRules[r];\n if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {\n // the atrule contains something that was referenced (likely by extend)\n // therefore it needs to be shown in output too\n return true;\n }\n }\n return false;\n }\n\n keepOnlyVisibleChilds(owner) {\n if (owner && owner.rules) {\n owner.rules = owner.rules.filter(thing => thing.isVisible());\n }\n }\n\n isEmpty(owner) {\n return (owner && owner.rules) \n ? (owner.rules.length === 0) : true;\n }\n\n hasVisibleSelector(rulesetNode) {\n return (rulesetNode && rulesetNode.paths)\n ? (rulesetNode.paths.length > 0) : false;\n }\n\n resolveVisibility(node) {\n if (!node.blocksVisibility()) {\n if (this.isEmpty(node)) {\n return ;\n }\n\n return node;\n }\n\n const compiledRulesBody = node.rules[0];\n this.keepOnlyVisibleChilds(compiledRulesBody);\n\n if (this.isEmpty(compiledRulesBody)) {\n return ;\n }\n\n node.ensureVisibility();\n node.removeVisibilityBlock();\n\n return node;\n }\n\n isVisibleRuleset(rulesetNode) {\n if (rulesetNode.firstRoot) {\n return true;\n }\n\n if (this.isEmpty(rulesetNode)) {\n return false;\n }\n\n if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {\n return false;\n }\n\n return true;\n }\n}\n\nconst ToCSSVisitor = function(context) {\n this._visitor = new Visitor(this);\n this._context = context;\n this.utils = new CSSVisitorUtils(context);\n};\n\nToCSSVisitor.prototype = {\n isReplacing: true,\n run: function (root) {\n return this._visitor.visit(root);\n },\n\n visitDeclaration: function (declNode, visitArgs) {\n if (declNode.blocksVisibility() || declNode.variable) {\n return;\n }\n return declNode;\n },\n\n visitMixinDefinition: function (mixinNode, visitArgs) {\n // mixin definitions do not get eval'd - this means they keep state\n // so we have to clear that state here so it isn't used if toCSS is called twice\n mixinNode.frames = [];\n },\n\n visitExtend: function (extendNode, visitArgs) {\n },\n\n visitComment: function (commentNode, visitArgs) {\n if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {\n return;\n }\n return commentNode;\n },\n\n visitMedia: function(mediaNode, visitArgs) {\n const originalRules = mediaNode.rules[0].rules;\n mediaNode.accept(this._visitor);\n visitArgs.visitDeeper = false;\n\n return this.utils.resolveVisibility(mediaNode, originalRules);\n },\n\n visitImport: function (importNode, visitArgs) {\n if (importNode.blocksVisibility()) {\n return ;\n }\n return importNode;\n },\n\n visitAtRule: function(atRuleNode, visitArgs) {\n if (atRuleNode.rules && atRuleNode.rules.length) {\n return this.visitAtRuleWithBody(atRuleNode, visitArgs);\n } else {\n return this.visitAtRuleWithoutBody(atRuleNode, visitArgs);\n }\n },\n\n visitAnonymous: function(anonymousNode, visitArgs) {\n if (!anonymousNode.blocksVisibility()) {\n anonymousNode.accept(this._visitor);\n return anonymousNode;\n }\n },\n\n visitAtRuleWithBody: function(atRuleNode, visitArgs) {\n // if there is only one nested ruleset and that one has no path, then it is\n // just fake ruleset\n function hasFakeRuleset(atRuleNode) {\n const bodyRules = atRuleNode.rules;\n return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);\n }\n function getBodyRules(atRuleNode) {\n const nodeRules = atRuleNode.rules;\n if (hasFakeRuleset(atRuleNode)) {\n return nodeRules[0].rules;\n }\n\n return nodeRules;\n }\n // it is still true that it is only one ruleset in array\n // this is last such moment\n // process childs\n const originalRules = getBodyRules(atRuleNode);\n atRuleNode.accept(this._visitor);\n visitArgs.visitDeeper = false;\n\n if (!this.utils.isEmpty(atRuleNode)) {\n this._mergeRules(atRuleNode.rules[0].rules);\n }\n\n return this.utils.resolveVisibility(atRuleNode, originalRules);\n },\n\n visitAtRuleWithoutBody: function(atRuleNode, visitArgs) {\n if (atRuleNode.blocksVisibility()) {\n return;\n }\n\n if (atRuleNode.name === '@charset') {\n // Only output the debug info together with subsequent @charset definitions\n // a comment (or @media statement) before the actual @charset atrule would\n // be considered illegal css as it has to be on the first line\n if (this.charset) {\n if (atRuleNode.debugInfo) {\n const comment = new tree.Comment(`/* ${atRuleNode.toCSS(this._context).replace(/\\n/g, '')} */\\n`);\n comment.debugInfo = atRuleNode.debugInfo;\n return this._visitor.visit(comment);\n }\n return;\n }\n this.charset = true;\n }\n\n return atRuleNode;\n },\n\n checkValidNodes: function(rules, isRoot) {\n if (!rules) {\n return;\n }\n\n for (let i = 0; i < rules.length; i++) {\n const ruleNode = rules[i];\n if (isRoot && ruleNode instanceof tree.Declaration && !ruleNode.variable) {\n throw { message: 'Properties must be inside selector blocks. They cannot be in the root',\n index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};\n }\n if (ruleNode instanceof tree.Call) {\n throw { message: `Function '${ruleNode.name}' did not return a root node`,\n index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};\n }\n if (ruleNode.type && !ruleNode.allowRoot) {\n throw { message: `${ruleNode.type} node returned by a function is not valid here`,\n index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};\n }\n }\n },\n\n visitRuleset: function (rulesetNode, visitArgs) {\n // at this point rulesets are nested into each other\n let rule;\n\n const rulesets = [];\n\n this.checkValidNodes(rulesetNode.rules, rulesetNode.firstRoot);\n\n if (!rulesetNode.root) {\n // remove invisible paths\n this._compileRulesetPaths(rulesetNode);\n\n // remove rulesets from this ruleset body and compile them separately\n const nodeRules = rulesetNode.rules;\n\n let nodeRuleCnt = nodeRules ? nodeRules.length : 0;\n for (let i = 0; i < nodeRuleCnt; ) {\n rule = nodeRules[i];\n if (rule && rule.rules) {\n // visit because we are moving them out from being a child\n rulesets.push(this._visitor.visit(rule));\n nodeRules.splice(i, 1);\n nodeRuleCnt--;\n continue;\n }\n i++;\n }\n // accept the visitor to remove rules and refactor itself\n // then we can decide nogw whether we want it or not\n // compile body\n if (nodeRuleCnt > 0) {\n rulesetNode.accept(this._visitor);\n } else {\n rulesetNode.rules = null;\n }\n visitArgs.visitDeeper = false;\n } else { // if (! rulesetNode.root) {\n rulesetNode.accept(this._visitor);\n visitArgs.visitDeeper = false;\n }\n\n if (rulesetNode.rules) {\n this._mergeRules(rulesetNode.rules);\n this._removeDuplicateRules(rulesetNode.rules);\n }\n\n // now decide whether we keep the ruleset\n if (this.utils.isVisibleRuleset(rulesetNode)) {\n rulesetNode.ensureVisibility();\n rulesets.splice(0, 0, rulesetNode);\n }\n\n if (rulesets.length === 1) {\n return rulesets[0];\n }\n return rulesets;\n },\n\n _compileRulesetPaths: function(rulesetNode) {\n if (rulesetNode.paths) {\n rulesetNode.paths = rulesetNode.paths\n .filter(p => {\n let i;\n if (p[0].elements[0].combinator.value === ' ') {\n p[0].elements[0].combinator = new(tree.Combinator)('');\n }\n for (i = 0; i < p.length; i++) {\n if (p[i].isVisible() && p[i].getIsOutput()) {\n return true;\n }\n }\n return false;\n });\n }\n },\n\n _removeDuplicateRules: function(rules) {\n if (!rules) { return; }\n\n // remove duplicates\n const ruleCache = {};\n\n for (let i = rules.length - 1; i >= 0 ; i--) {\n let rule = rules[i];\n if (rule instanceof tree.Declaration) {\n if (!Object.prototype.hasOwnProperty.call(ruleCache, rule.name)) {\n ruleCache[rule.name] = rule;\n } else {\n let ruleList = ruleCache[rule.name];\n if (!Array.isArray(ruleList)) {\n const prevRuleCSS = ruleList.toCSS(this._context);\n ruleList = ruleCache[rule.name] = [prevRuleCSS];\n }\n const ruleCSS = rule.toCSS(this._context);\n if (ruleList.indexOf(ruleCSS) !== -1) {\n rules.splice(i, 1);\n } else {\n ruleList.push(ruleCSS);\n }\n }\n }\n }\n },\n\n _mergeRules: mergeRules\n};\n\nexport default ToCSSVisitor;\n"
},
{
"path": "packages/less/lib/less/visitors/visitor.js",
"content": "import tree from '../tree/index.js';\n\nconst _visitArgs = { visitDeeper: true };\nlet _hasIndexed = false;\n\nfunction _noop(node) {\n return node;\n}\n\nfunction indexNodeTypes(parent, ticker) {\n // add .typeIndex to tree node types for lookup table\n let key, child;\n for (key in parent) { \n /* eslint guard-for-in: 0 */\n child = parent[key];\n switch (typeof child) {\n case 'function':\n // ignore bound functions directly on tree which do not have a prototype\n // or aren't nodes\n if (child.prototype && child.prototype.type) {\n child.prototype.typeIndex = ticker++;\n }\n break;\n case 'object':\n ticker = indexNodeTypes(child, ticker);\n break;\n \n }\n }\n return ticker;\n}\n\nclass Visitor {\n constructor(implementation) {\n this._implementation = implementation;\n this._visitInCache = {};\n this._visitOutCache = {};\n\n if (!_hasIndexed) {\n indexNodeTypes(tree, 1);\n _hasIndexed = true;\n }\n }\n\n visit(node) {\n if (!node) {\n return node;\n }\n\n const nodeTypeIndex = node.typeIndex;\n if (!nodeTypeIndex) {\n // MixinCall args aren't a node type?\n if (node.value && node.value.typeIndex) {\n this.visit(node.value);\n }\n return node;\n }\n\n const impl = this._implementation;\n let func = this._visitInCache[nodeTypeIndex];\n let funcOut = this._visitOutCache[nodeTypeIndex];\n const visitArgs = _visitArgs;\n let fnName;\n\n visitArgs.visitDeeper = true;\n\n if (!func) {\n fnName = `visit${node.type}`;\n func = impl[fnName] || _noop;\n funcOut = impl[`${fnName}Out`] || _noop;\n this._visitInCache[nodeTypeIndex] = func;\n this._visitOutCache[nodeTypeIndex] = funcOut;\n }\n\n if (func !== _noop) {\n const newNode = func.call(impl, node, visitArgs);\n if (node && impl.isReplacing) {\n node = newNode;\n }\n }\n\n if (visitArgs.visitDeeper && node) {\n if (node.length) {\n for (let i = 0, cnt = node.length; i < cnt; i++) {\n if (node[i].accept) {\n node[i].accept(this);\n }\n }\n } else if (node.accept) {\n node.accept(this);\n }\n }\n\n if (funcOut != _noop) {\n funcOut.call(impl, node);\n }\n\n return node;\n }\n\n visitArray(nodes, nonReplacing) {\n if (!nodes) {\n return nodes;\n }\n\n const cnt = nodes.length;\n let i;\n\n // Non-replacing\n if (nonReplacing || !this._implementation.isReplacing) {\n for (i = 0; i < cnt; i++) {\n this.visit(nodes[i]);\n }\n return nodes;\n }\n\n // Replacing\n const out = [];\n for (i = 0; i < cnt; i++) {\n const evald = this.visit(nodes[i]);\n if (evald === undefined) { continue; }\n if (!evald.splice) {\n out.push(evald);\n } else if (evald.length) {\n this.flatten(evald, out);\n }\n }\n return out;\n }\n\n flatten(arr, out) {\n if (!out) {\n out = [];\n }\n\n let cnt, i, item, nestedCnt, j, nestedItem;\n\n for (i = 0, cnt = arr.length; i < cnt; i++) {\n item = arr[i];\n if (item === undefined) {\n continue;\n }\n if (!item.splice) {\n out.push(item);\n continue;\n }\n\n for (j = 0, nestedCnt = item.length; j < nestedCnt; j++) {\n nestedItem = item[j];\n if (nestedItem === undefined) {\n continue;\n }\n if (!nestedItem.splice) {\n out.push(nestedItem);\n } else if (nestedItem.length) {\n this.flatten(nestedItem, out);\n }\n }\n }\n\n return out;\n }\n}\n\nexport default Visitor;\n"
},
{
"path": "packages/less/lib/less-browser/add-default-options.js",
"content": "import {addDataAttr} from './utils.js';\nimport browser from './browser.js';\n\n/**\n * @param {Window} window\n * @param {Record} options\n */\nexport default (window, options) => {\n\n // use options from the current script tag data attribues\n addDataAttr(options, browser.currentScript(window));\n\n if (options.isFileProtocol === undefined) {\n options.isFileProtocol = /^(file|(chrome|safari)(-extension)?|resource|qrc|app):/.test(window.location.protocol);\n }\n\n // Load styles asynchronously (default: false)\n //\n // This is set to `false` by default, so that the body\n // doesn't start loading before the stylesheets are parsed.\n // Setting this to `true` can result in flickering.\n //\n options.async = options.async || false;\n options.fileAsync = options.fileAsync || false;\n\n // Interval between watch polls\n options.poll = options.poll || (options.isFileProtocol ? 1000 : 1500);\n\n options.env = options.env || (window.location.hostname == '127.0.0.1' ||\n window.location.hostname == '0.0.0.0' ||\n window.location.hostname == 'localhost' ||\n (window.location.port &&\n window.location.port.length > 0) ||\n options.isFileProtocol ? 'development'\n : 'production');\n\n const dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(window.location.hash);\n if (dumpLineNumbers) {\n options.dumpLineNumbers = dumpLineNumbers[1];\n }\n\n if (options.useFileCache === undefined) {\n options.useFileCache = true;\n }\n\n if (options.onReady === undefined) {\n options.onReady = true;\n }\n\n if (options.relativeUrls) {\n options.rewriteUrls = 'all';\n }\n};\n"
},
{
"path": "packages/less/lib/less-browser/bootstrap.js",
"content": "/**\n * Kicks off less and compiles any stylesheets\n * used in the browser distributed version of less\n * to kick-start less using the browser api\n */\nimport defaultOptions from '../less/default-options.js';\nimport addDefaultOptions from './add-default-options.js';\nimport root from './index.js';\n\nconst options = defaultOptions();\n\nif (window.less) {\n for (const key in window.less) {\n if (Object.prototype.hasOwnProperty.call(window.less, key)) {\n options[key] = window.less[key];\n }\n }\n}\naddDefaultOptions(window, options);\n\noptions.plugins = options.plugins || [];\n\nif (window.LESS_PLUGINS) {\n options.plugins = options.plugins.concat(window.LESS_PLUGINS);\n}\n\nconst less = root(window, options);\nexport default less;\n\nwindow.less = less;\n\nlet css;\nlet head;\nlet style;\n\n// Always restore page visibility\nfunction resolveOrReject(data) {\n if (data.filename) {\n console.warn(data);\n }\n if (!options.async) {\n head.removeChild(style);\n }\n}\n\nif (options.onReady) {\n if (/!watch/.test(window.location.hash)) {\n less.watch();\n }\n // Simulate synchronous stylesheet loading by hiding page rendering\n if (!options.async) {\n css = 'body { display: none !important }';\n head = document.head || document.getElementsByTagName('head')[0];\n style = document.createElement('style');\n\n style.type = 'text/css';\n if (style.styleSheet) {\n style.styleSheet.cssText = css;\n } else {\n style.appendChild(document.createTextNode(css));\n }\n\n head.appendChild(style);\n }\n less.registerStylesheetsImmediately();\n less.pageLoadFinished = less.refresh(less.env === 'development').then(resolveOrReject, resolveOrReject);\n}\n"
},
{
"path": "packages/less/lib/less-browser/browser.js",
"content": "import * as utils from './utils.js';\n\nexport default {\n createCSS: function (document, styles, sheet) {\n // Strip the query-string\n const href = sheet.href || '';\n\n // If there is no title set, use the filename, minus the extension\n const id = `less:${sheet.title || utils.extractId(href)}`;\n\n // If this has already been inserted into the DOM, we may need to replace it\n const oldStyleNode = document.getElementById(id);\n let keepOldStyleNode = false;\n\n // Create a new stylesheet node for insertion or (if necessary) replacement\n const styleNode = document.createElement('style');\n styleNode.setAttribute('type', 'text/css');\n if (sheet.media) {\n styleNode.setAttribute('media', sheet.media);\n }\n styleNode.id = id;\n\n if (!styleNode.styleSheet) {\n styleNode.appendChild(document.createTextNode(styles));\n\n // If new contents match contents of oldStyleNode, don't replace oldStyleNode\n keepOldStyleNode = (oldStyleNode !== null && oldStyleNode.childNodes.length > 0 && styleNode.childNodes.length > 0 &&\n oldStyleNode.firstChild.nodeValue === styleNode.firstChild.nodeValue);\n }\n\n const head = document.getElementsByTagName('head')[0];\n\n // If there is no oldStyleNode, just append; otherwise, only append if we need\n // to replace oldStyleNode with an updated stylesheet\n if (oldStyleNode === null || keepOldStyleNode === false) {\n const nextEl = sheet && sheet.nextSibling || null;\n if (nextEl) {\n nextEl.parentNode.insertBefore(styleNode, nextEl);\n } else {\n head.appendChild(styleNode);\n }\n }\n if (oldStyleNode && keepOldStyleNode === false) {\n oldStyleNode.parentNode.removeChild(oldStyleNode);\n }\n\n // For IE.\n // This needs to happen *after* the style element is added to the DOM, otherwise IE 7 and 8 may crash.\n // See http://social.msdn.microsoft.com/Forums/en-US/7e081b65-878a-4c22-8e68-c10d39c2ed32/internet-explorer-crashes-appending-style-element-to-head\n if (styleNode.styleSheet) {\n try {\n styleNode.styleSheet.cssText = styles;\n } catch (e) {\n throw new Error('Couldn\\'t reassign styleSheet.cssText.');\n }\n }\n },\n currentScript: function(window) {\n const document = window.document;\n return document.currentScript || (() => {\n const scripts = document.getElementsByTagName('script');\n return scripts[scripts.length - 1];\n })();\n }\n};\n"
},
{
"path": "packages/less/lib/less-browser/cache.js",
"content": "// Cache system is a bit outdated and could do with work\n\nexport default (window, options, logger) => {\n let cache = null;\n if (options.env !== 'development') {\n try {\n cache = (typeof window.localStorage === 'undefined') ? null : window.localStorage;\n } catch (_) {}\n }\n return {\n setCSS: function(path, lastModified, modifyVars, styles) {\n if (cache) {\n logger.info(`saving ${path} to cache.`);\n try {\n cache.setItem(path, styles);\n cache.setItem(`${path}:timestamp`, lastModified);\n if (modifyVars) {\n cache.setItem(`${path}:vars`, JSON.stringify(modifyVars));\n }\n } catch (e) {\n // TODO - could do with adding more robust error handling\n logger.error(`failed to save \"${path}\" to local storage for caching.`);\n }\n }\n },\n getCSS: function(path, webInfo, modifyVars) {\n const css = cache && cache.getItem(path);\n const timestamp = cache && cache.getItem(`${path}:timestamp`);\n let vars = cache && cache.getItem(`${path}:vars`);\n\n modifyVars = modifyVars || {};\n vars = vars || '{}'; // if not set, treat as the JSON representation of an empty object\n\n if (timestamp && webInfo.lastModified &&\n (new Date(webInfo.lastModified).valueOf() ===\n new Date(timestamp).valueOf()) &&\n JSON.stringify(modifyVars) === vars) {\n // Use local copy\n return css;\n }\n }\n };\n};\n"
},
{
"path": "packages/less/lib/less-browser/error-reporting.js",
"content": "import * as utils from './utils.js';\nimport browser from './browser.js';\n\nexport default (window, less, options) => {\n\n function errorHTML(e, rootHref) {\n const id = `less-error-message:${utils.extractId(rootHref || '')}`;\n const template = '{line} {content} ${e.type || 'Syntax'}Error: ${e.message || 'There is an error in your .less file'}` + \n ` in ${filenameNoPath} `;\n\n const errorline = (e, i, classname) => {\n if (e.extract[i] !== undefined) {\n errors.push(template.replace(/\\{line\\}/, (parseInt(e.line, 10) || 0) + (i - 1))\n .replace(/\\{class\\}/, classname)\n .replace(/\\{content\\}/, e.extract[i]));\n }\n };\n\n if (e.line) {\n errorline(e, 0, '');\n errorline(e, 1, 'line');\n errorline(e, 2, '');\n content += `on line ${e.line}, column ${e.column + 1}:
`;\n }\n if (e.stack && (e.extract || options.logLevel >= 4)) {\n content += `} options\n * @param {HTMLElement | null} tag\n */\nexport function addDataAttr(options, tag) {\n if (!tag) {return;} // in case of tag is null or undefined\n for (const opt in tag.dataset) {\n if (Object.prototype.hasOwnProperty.call(tag.dataset, opt)) {\n if (opt === 'env' || opt === 'dumpLineNumbers' || opt === 'rootpath' || opt === 'errorReporting') {\n options[opt] = tag.dataset[opt];\n } else {\n try {\n options[opt] = JSON.parse(tag.dataset[opt]);\n }\n catch (_) {}\n }\n }\n }\n}\n"
},
{
"path": "packages/less/lib/less-node/environment.js",
"content": "import { createRequire } from 'module';\n\nconst require = createRequire(import.meta.url);\n\nclass SourceMapGeneratorFallback {\n addMapping(){}\n setSourceContent(){}\n toJSON(){\n return null;\n }\n};\n\nexport default {\n encodeBase64: function encodeBase64(str) {\n // Avoid Buffer constructor on newer versions of Node.js.\n const buffer = (Buffer.from ? Buffer.from(str) : (new Buffer(str)));\n return buffer.toString('base64');\n },\n mimeLookup: function (filename) {\n try {\n const mimeModule = require('mime');\n return mimeModule ? mimeModule.lookup(filename) : \"application/octet-stream\";\n } catch (e) {\n return \"application/octet-stream\";\n }\n },\n charsetLookup: function (mime) {\n try {\n const mimeModule = require('mime');\n return mimeModule ? mimeModule.charsets.lookup(mime) : undefined;\n } catch (e) {\n return undefined;\n }\n },\n getSourceMapGenerator: function getSourceMapGenerator() {\n try {\n const sourceMapModule = require('source-map');\n return sourceMapModule ? sourceMapModule.SourceMapGenerator : SourceMapGeneratorFallback;\n } catch (e) {\n return SourceMapGeneratorFallback;\n }\n }\n};\n"
},
{
"path": "packages/less/lib/less-node/file-manager.js",
"content": "import path from 'path';\nimport { createRequire } from 'module';\nimport fs from './fs.js';\nimport AbstractFileManager from '../less/environment/abstract-file-manager.js';\n\nconst require = createRequire(import.meta.url);\n\nconst FileManager = function() {}\nFileManager.prototype = Object.assign(new AbstractFileManager(), {\n supports() {\n return true;\n },\n\n supportsSync() {\n return true;\n },\n\n loadFile(filename, currentDirectory, options, environment, callback) {\n let fullFilename;\n const isAbsoluteFilename = this.isPathAbsolute(filename);\n const filenamesTried = [];\n const self = this;\n const prefix = filename.slice(0, 1);\n const explicit = prefix === '.' || prefix === '/';\n let result = null;\n let isNodeModule = false;\n const npmPrefix = 'npm://';\n\n options = options || {};\n\n const paths = isAbsoluteFilename ? [''] : [currentDirectory];\n\n if (options.paths) { paths.push.apply(paths, options.paths); }\n\n if (!isAbsoluteFilename && paths.indexOf('.') === -1) { paths.push('.'); }\n\n const prefixes = options.prefixes || [''];\n const fileParts = this.extractUrlParts(filename);\n\n if (options.syncImport) {\n getFileData(returnData, returnData);\n if (callback) {\n callback(result.error, result);\n }\n else {\n return result;\n }\n }\n else {\n // promise is guaranteed to be asyncronous\n // which helps as it allows the file handle\n // to be closed before it continues with the next file\n return new Promise(getFileData);\n }\n\n function returnData(data) {\n if (!data.filename) {\n result = { error: data };\n }\n else {\n result = data;\n }\n }\n\n function getFileData(fulfill, reject) {\n (function tryPathIndex(i) {\n function tryWithExtension() {\n const extFilename = options.ext ? self.tryAppendExtension(fullFilename, options.ext) : fullFilename;\n\n if (extFilename !== fullFilename && !explicit && paths[i] === '.') {\n try {\n fullFilename = require.resolve(extFilename);\n isNodeModule = true;\n }\n catch (e) {\n filenamesTried.push(npmPrefix + extFilename);\n fullFilename = extFilename;\n }\n }\n else {\n fullFilename = extFilename;\n }\n }\n if (i < paths.length) {\n (function tryPrefix(j) {\n if (j < prefixes.length) {\n isNodeModule = false;\n fullFilename = fileParts.rawPath + prefixes[j] + fileParts.filename;\n\n if (paths[i]) {\n if (paths[i].startsWith('#')) {\n // Handling paths starting with '#'\n fullFilename = paths[i].substr(1) + fullFilename;\n }else{\n fullFilename = path.join(paths[i], fullFilename);\n }\n }\n\n if (!explicit && paths[i] === '.') {\n try {\n fullFilename = require.resolve(fullFilename);\n isNodeModule = true;\n }\n catch (e) {\n filenamesTried.push(npmPrefix + fullFilename);\n tryWithExtension();\n }\n }\n else {\n tryWithExtension();\n } \n\n const readFileArgs = [fullFilename];\n if (!options.rawBuffer) {\n readFileArgs.push('utf-8');\n }\n if (options.syncImport) {\n try {\n const data = fs.readFileSync.apply(this, readFileArgs);\n fulfill({ contents: data, filename: fullFilename});\n }\n catch (e) {\n filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);\n return tryPrefix(j + 1);\n }\n }\n else {\n readFileArgs.push(function(e, data) {\n if (e) {\n filenamesTried.push(isNodeModule ? npmPrefix + fullFilename : fullFilename);\n return tryPrefix(j + 1);\n } \n fulfill({ contents: data, filename: fullFilename});\n });\n fs.readFile.apply(this, readFileArgs);\n }\n\n }\n else {\n tryPathIndex(i + 1);\n }\n })(0);\n } else {\n reject({ type: 'File', message: `'${filename}' wasn't found. Tried - ${filenamesTried.join(',')}` });\n }\n }(0));\n }\n },\n\n loadFileSync(filename, currentDirectory, options, environment) {\n options.syncImport = true;\n return this.loadFile(filename, currentDirectory, options, environment);\n }\n});\n\nexport default FileManager;\n"
},
{
"path": "packages/less/lib/less-node/fs.js",
"content": "/** @typedef {import('fs')} FS */\nimport nodeFs from 'fs';\nimport { createRequire } from 'module';\n\nconst require = createRequire(import.meta.url);\n\n/** @type {FS} */\nlet fs;\ntry {\n fs = require('graceful-fs');\n} catch (e) {\n fs = nodeFs;\n}\nexport default fs;\n"
},
{
"path": "packages/less/lib/less-node/image-size.js",
"content": "import { createRequire } from 'module';\nimport Dimension from '../less/tree/dimension.js';\nimport Expression from '../less/tree/expression.js';\nimport functionRegistry from './../less/functions/function-registry.js';\n\nconst require = createRequire(import.meta.url);\n\nexport default environment => {\n\n function imageSize(functionContext, filePathNode) {\n let filePath = filePathNode.value;\n const currentFileInfo = functionContext.currentFileInfo;\n const currentDirectory = currentFileInfo.rewriteUrls ?\n currentFileInfo.currentDirectory : currentFileInfo.entryPath;\n\n const fragmentStart = filePath.indexOf('#');\n if (fragmentStart !== -1) {\n filePath = filePath.slice(0, fragmentStart);\n }\n\n const fileManager = environment.getFileManager(filePath, currentDirectory, functionContext.context, environment, true);\n\n if (!fileManager) {\n throw {\n type: 'File',\n message: `Can not set up FileManager for ${filePathNode}`\n };\n }\n\n const fileSync = fileManager.loadFileSync(filePath, currentDirectory, functionContext.context, environment);\n\n if (fileSync.error) {\n throw fileSync.error;\n }\n\n const sizeOf = require('image-size');\n return sizeOf ? sizeOf(fileSync.filename) : {width: 0, height: 0};\n }\n\n const imageFunctions = {\n 'image-size': function(filePathNode) {\n const size = imageSize(this, filePathNode);\n return new Expression([\n new Dimension(size.width, 'px'),\n new Dimension(size.height, 'px')\n ]);\n },\n 'image-width': function(filePathNode) {\n const size = imageSize(this, filePathNode);\n return new Dimension(size.width, 'px');\n },\n 'image-height': function(filePathNode) {\n const size = imageSize(this, filePathNode);\n return new Dimension(size.height, 'px');\n }\n };\n\n functionRegistry.addMultiple(imageFunctions);\n};\n"
},
{
"path": "packages/less/lib/less-node/index.js",
"content": "import { createRequire } from 'module';\nimport environment from './environment.js';\nimport FileManager from './file-manager.js';\nimport UrlFileManager from './url-file-manager.js';\nimport createFromEnvironment from '../less/index.js';\nimport lesscHelper from './lessc-helper.js';\nimport PluginLoader from './plugin-loader.js';\nimport fs from './fs.js';\nimport defaultOptions from '../less/default-options.js';\nimport imageSize from './image-size.js';\n\nconst require = createRequire(import.meta.url);\nconst { version } = require('../../package.json');\n\nconst less = createFromEnvironment(environment, [new FileManager(), new UrlFileManager()], version);\n\n// allow people to create less with their own environment\nless.createFromEnvironment = createFromEnvironment;\nless.lesscHelper = lesscHelper;\nless.PluginLoader = PluginLoader;\nless.fs = fs;\nless.FileManager = FileManager;\nless.UrlFileManager = UrlFileManager;\n\n// Set up options\nless.options = defaultOptions();\n\n// provide image-size functionality\nimageSize(less.environment);\n\nexport default less;\n"
},
{
"path": "packages/less/lib/less-node/lessc-helper.js",
"content": "// lessc_helper.js\n//\n// helper functions for lessc\nconst lessc_helper = {\n\n // Stylize a string\n stylize : function(str, style) {\n const styles = {\n 'reset' : [0, 0],\n 'bold' : [1, 22],\n 'inverse' : [7, 27],\n 'underline' : [4, 24],\n 'yellow' : [33, 39],\n 'green' : [32, 39],\n 'red' : [31, 39],\n 'grey' : [90, 39]\n };\n return `\\x1b[${styles[style][0]}m${str}\\x1b[${styles[style][1]}m`;\n },\n\n // Print command line options\n printUsage: function() {\n console.log('usage: lessc [option option=parameter ...] [destination]');\n console.log('');\n console.log('If source is set to `-\\' (dash or hyphen-minus), input is read from stdin.');\n console.log('');\n console.log('options:');\n console.log(' -h, --help Prints help (this message) and exit.');\n console.log(' --include-path=PATHS Sets include paths. Separated by `:\\'. `;\\' also supported on windows.');\n console.log(' -M, --depends Outputs a makefile import dependency list to stdout.');\n console.log(' --no-color Disables colorized output.');\n console.log(' --ie-compat Enables IE8 compatibility checks.');\n console.log(' --js Enables inline JavaScript in less files');\n console.log(' -l, --lint Syntax check only (lint).');\n console.log(' -s, --silent Suppresses output of error messages.');\n console.log(' --quiet Suppresses output of warnings.');\n console.log(' --strict-imports (DEPRECATED) Ignores .less imports inside selector blocks. Has confusing behavior.');\n console.log(' --insecure Allows imports from insecure https hosts.');\n console.log(' -v, --version Prints version number and exit.');\n console.log(' --verbose Be verbose.');\n console.log(' --source-map[=FILENAME] Outputs a v3 sourcemap to the filename (or output filename.map).');\n console.log(' --source-map-rootpath=X Adds this path onto the sourcemap filename and less file paths.');\n console.log(' --source-map-basepath=X Sets sourcemap base path, defaults to current working directory.');\n console.log(' --source-map-include-source Puts the less files into the map instead of referencing them.');\n console.log(' --source-map-inline Puts the map (and any less files) as a base64 data uri into the output css file.');\n console.log(' --source-map-url=URL Sets a custom URL to map file, for sourceMappingURL comment');\n console.log(' in generated CSS file.');\n console.log(' --source-map-no-annotation Excludes the sourceMappingURL comment from the output css file.');\n console.log(' -rp, --rootpath=URL Sets rootpath for url rewriting in relative imports and urls');\n console.log(' Works with or without the relative-urls option.');\n console.log(' -ru=, --rewrite-urls= Rewrites URLs to make them relative to the base less file.');\n console.log(' all|local|off \\'all\\' rewrites all URLs, \\'local\\' just those starting with a \\'.\\'');\n console.log('');\n console.log(' -m=, --math=');\n console.log(' always Less will eagerly perform math operations always.');\n console.log(' parens-division Math performed except for division (/) operator');\n console.log(' parens | strict Math only performed inside parentheses');\n console.log(' strict-legacy Parens required in very strict terms (legacy --strict-math)');\n console.log('');\n console.log(' -su=on|off Allows mixed units, e.g. 1px+1em or 1px*1px which have units');\n console.log(' --strict-units=on|off that cannot be represented.');\n console.log(' --global-var=\\'VAR=VALUE\\' Defines a variable that can be referenced by the file.');\n console.log(' --modify-var=\\'VAR=VALUE\\' Modifies a variable already declared in the file.');\n console.log(' --url-args=\\'QUERYSTRING\\' Adds params into url tokens (e.g. 42, cb=42 or \\'a=1&b=2\\')');\n console.log(' --plugin=PLUGIN=OPTIONS Loads a plugin. You can also omit the --plugin= if the plugin begins');\n console.log(' less-plugin. E.g. the clean css plugin is called less-plugin-clean-css');\n console.log(' once installed (npm install less-plugin-clean-css), use either with');\n console.log(' --plugin=less-plugin-clean-css or just --clean-css');\n console.log(' specify options afterwards e.g. --plugin=less-plugin-clean-css=\"advanced\"');\n console.log(' or --clean-css=\"advanced\"');\n console.log(' --disable-plugin-rule Disallow @plugin statements');\n console.log('');\n console.log(' --quiet-deprecations Suppress deprecation warnings only (keeps other warnings).');\n console.log('');\n console.log('-------------------------- Deprecated ----------------');\n console.log(' -sm=on|off Legacy parens-only math. Use --math');\n console.log(' --strict-math=on|off ');\n console.log('');\n console.log(' --line-numbers=TYPE (DEPRECATED) Outputs filename and line numbers.');\n console.log(' TYPE can be either \\'comments\\', \\'mediaquery\\', or \\'all\\'.');\n console.log(' The entire dumpLineNumbers option is deprecated.');\n console.log(' Use sourcemaps (--source-map) instead.');\n console.log(' All modes will be removed in a future version.');\n console.log(' Note: \\'mediaquery\\' and \\'all\\' modes generate @media -sass-debug-info');\n console.log(' which had short-lived usage and is no longer recommended.');\n console.log(' -x, --compress Compresses output by removing some whitespaces.');\n console.log(' We recommend you use a dedicated minifer like less-plugin-clean-css');\n console.log('');\n console.log('Report bugs to: http://github.com/less/less.js/issues');\n console.log('Home page: ![](\"http://lesscss.org/public/img/less_logo.png\"){kind=logo}
![\"Github](\"https://github.com/less/less.js/actions/workflows/ci.yml/badge.svg?branch=master\"){kind=icon}
\n ![\"Downloads\"](\"https://img.shields.io/npm/dm/less.svg?sanitize=true\")
\n ![](\"https://img.shields.io/npm/v/less.svg?sanitize=true\")
\n ![\"Twitter](\"https://img.shields.io/twitter/follow/lesstocss.svg?style=flat-square\")
\n![](\"https://opencollective.com/less/contributors.svg?width=890&button=false\")
\n\n\n\n\n![\"Matthew](\"https://avatars.githubusercontent.com/u/414752?v=4?s=100\")
![\"Alexis](\"https://avatars.githubusercontent.com/u/40774?v=4?s=100\")
![\"Luke](\"https://avatars.githubusercontent.com/u/309321?v=4?s=100\")
![\"Max](\"https://avatars.githubusercontent.com/u/5304376?v=4?s=100\")
![\"Lei](\"https://avatars.githubusercontent.com/u/14012511?v=4?s=100\")
![\"Daniel](\"https://avatars.githubusercontent.com/u/3059609?v=4?s=100\")
![](\"https://raw.githubusercontent.com/all-contributors/all-contributors-cli/1b8533af435da9854653492b1327a23a4dbd0a10/assets/logo-small.svg\"){kind=logo}
\n Add your contributions\n \n