Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/clean-css/lib/optimizer/level-2/reduce-non-adjacent.js
49c99f97fe9aissn4frontend

reduce-non-adjacent.js
View Options

			var isMergeable = require('./is-mergeable');

			var optimizeProperties = require('./properties/optimize');

			var cloneArray = require('../../utils/clone-array');

			var Token = require('../../tokenizer/token');

			var serializeBody = require('../../writer/one-time').body;
			var serializeRules = require('../../writer/one-time').rules;

			function reduceNonAdjacent(tokens, context) {
			var options = context.options;
			var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
			var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
			var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
			var candidates = {};
			var repeated = [];

			for (var i = tokens.length - 1; i >= 0; i--) {
			var token = tokens[i];

			if (token[0] != Token.RULE) {
			continue;
			} else if (token[2].length === 0) {
			continue;
			}

			var selectorAsString = serializeRules(token[1]);
			var isComplexAndNotSpecial = token[1].length > 1
			&& isMergeable(selectorAsString, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging);
			var wrappedSelectors = wrappedSelectorsFrom(token[1]);
			var selectors = isComplexAndNotSpecial
			? [selectorAsString].concat(wrappedSelectors)
			: [selectorAsString];

			for (var j = 0, m = selectors.length; j < m; j++) {
			var selector = selectors[j];

			if (!candidates[selector]) { candidates[selector] = []; } else { repeated.push(selector); }

			candidates[selector].push({
			where: i,
			list: wrappedSelectors,
			isPartial: isComplexAndNotSpecial && j > 0,
			isComplex: isComplexAndNotSpecial && j === 0
			});
			}
			}

			reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context);
			reduceComplexNonAdjacentCases(tokens, candidates, options, context);
			}

			function wrappedSelectorsFrom(list) {
			var wrapped = [];

			for (var i = 0; i < list.length; i++) {
			wrapped.push([list[i][1]]);
			}

			return wrapped;
			}

			function reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context) {
			function filterOut(idx, bodies) {
			return data[idx].isPartial && bodies.length === 0;
			}

			function reduceBody(token, newBody, processedCount, tokenIdx) {
			if (!data[processedCount - tokenIdx - 1].isPartial) { token[2] = newBody; }
			}

			for (var i = 0, l = repeated.length; i < l; i++) {
			var selector = repeated[i];
			var data = candidates[selector];

			reduceSelector(tokens, data, {
			filterOut: filterOut,
			callback: reduceBody
			}, options, context);
			}
			}

			function reduceComplexNonAdjacentCases(tokens, candidates, options, context) {
			var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses;
			var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements;
			var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging;
			var localContext = {};

			function filterOut(idx) {
			return localContext.data[idx].where < localContext.intoPosition;
			}

			function collectReducedBodies(token, newBody, processedCount, tokenIdx) {
			if (tokenIdx === 0) { localContext.reducedBodies.push(newBody); }
			}

			allSelectors:
			for (var complexSelector in candidates) {
			var into = candidates[complexSelector];
			if (!into[0].isComplex) { continue; }

			var intoPosition = into[into.length - 1].where;
			var intoToken = tokens[intoPosition];
			var reducedBodies = [];

			var selectors = isMergeable(complexSelector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging)
			? into[0].list
			: [complexSelector];

			localContext.intoPosition = intoPosition;
			localContext.reducedBodies = reducedBodies;

			for (var j = 0, m = selectors.length; j < m; j++) {
			var selector = selectors[j];
			var data = candidates[selector];

			if (data.length < 2) { continue allSelectors; }

			localContext.data = data;

			reduceSelector(tokens, data, {
			filterOut: filterOut,
			callback: collectReducedBodies
			}, options, context);

			if (serializeBody(reducedBodies[reducedBodies.length - 1]) != serializeBody(reducedBodies[0])) {
			continue allSelectors;
			}
			}

			intoToken[2] = reducedBodies[0];
			}
			}

			function reduceSelector(tokens, data, context, options, outerContext) {
			var bodies = [];
			var bodiesAsList = [];
			var processedTokens = [];

			for (var j = data.length - 1; j >= 0; j--) {
			if (context.filterOut(j, bodies)) { continue; }

			var where = data[j].where;
			var token = tokens[where];
			var clonedBody = cloneArray(token[2]);

			bodies = bodies.concat(clonedBody);
			bodiesAsList.push(clonedBody);
			processedTokens.push(where);
			}

			optimizeProperties(bodies, true, false, outerContext);

			var processedCount = processedTokens.length;
			var propertyIdx = bodies.length - 1;
			var tokenIdx = processedCount - 1;

			while (tokenIdx >= 0) {
			if ((tokenIdx === 0
			\|\| (bodies[propertyIdx] && bodiesAsList[tokenIdx].indexOf(bodies[propertyIdx]) > -1)) && propertyIdx > -1) {
			propertyIdx--;
			continue;
			}

			var newBody = bodies.splice(propertyIdx + 1);
			context.callback(tokens[processedTokens[tokenIdx]], newBody, processedCount, tokenIdx);

			tokenIdx--;
			}
			}

			module.exports = reduceNonAdjacent;