| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/jungly/node_modules/postcss-merge-rules/dist/ |
Upload File : |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _browserslist = require('browserslist');
var _browserslist2 = _interopRequireDefault(_browserslist);
var _postcss = require('postcss');
var _postcss2 = _interopRequireDefault(_postcss);
var _vendors = require('vendors');
var _vendors2 = _interopRequireDefault(_vendors);
var _cssnanoUtilSameParent = require('cssnano-util-same-parent');
var _cssnanoUtilSameParent2 = _interopRequireDefault(_cssnanoUtilSameParent);
var _ensureCompatibility = require('./lib/ensureCompatibility');
var _ensureCompatibility2 = _interopRequireDefault(_ensureCompatibility);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const prefixes = _vendors2.default.map(v => `-${v}-`);
function intersect(a, b, not) {
return a.filter(c => {
const index = ~b.indexOf(c);
return not ? !index : index;
});
}
// Internet Explorer use :-ms-input-placeholder.
// Microsoft Edge use ::-ms-input-placeholder.
const findMsInputPlaceholder = selector => ~selector.search(/-ms-input-placeholder/i);
const different = (a, b) => intersect(a, b, true).concat(intersect(b, a, true));
const filterPrefixes = selector => intersect(prefixes, selector);
function sameVendor(selectorsA, selectorsB) {
let same = selectors => selectors.map(filterPrefixes).join();
let findMsVendor = selectors => selectors.find(findMsInputPlaceholder);
return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
}
const noVendor = selector => !filterPrefixes(selector).length;
function canMerge(ruleA, ruleB, browsers, compatibilityCache) {
const a = ruleA.selectors;
const b = ruleB.selectors;
const selectors = a.concat(b);
if (!(0, _ensureCompatibility2.default)(selectors, browsers, compatibilityCache)) {
return false;
}
const parent = (0, _cssnanoUtilSameParent2.default)(ruleA, ruleB);
const { name } = ruleA.parent;
if (parent && name && ~name.indexOf('keyframes')) {
return false;
}
return parent && (selectors.every(noVendor) || sameVendor(a, b));
}
const getDecls = rule => rule.nodes && rule.nodes.map(String);
const joinSelectors = (...rules) => rules.map(s => s.selector).join();
function ruleLength(...rules) {
return rules.map(r => r.nodes.length ? String(r) : '').join('').length;
}
function splitProp(prop) {
const parts = prop.split('-');
let base, rest;
// Treat vendor prefixed properties as if they were unprefixed;
// moving them when combined with non-prefixed properties can
// cause issues. e.g. moving -webkit-background-clip when there
// is a background shorthand definition.
if (prop[0] === '-') {
base = parts[2];
rest = parts.slice(3);
} else {
base = parts[0];
rest = parts.slice(1);
}
return [base, rest];
}
function isConflictingProp(propA, propB) {
if (propA === propB) {
return true;
}
const a = splitProp(propA);
const b = splitProp(propB);
return a[0] === b[0] && a[1].length !== b[1].length;
}
function hasConflicts(declProp, notMoved) {
return notMoved.some(prop => isConflictingProp(prop, declProp));
}
function partialMerge(first, second) {
let intersection = intersect(getDecls(first), getDecls(second));
if (!intersection.length) {
return second;
}
let nextRule = second.next();
if (nextRule && nextRule.type === 'rule' && canMerge(second, nextRule)) {
let nextIntersection = intersect(getDecls(second), getDecls(nextRule));
if (nextIntersection.length > intersection.length) {
first = second;second = nextRule;intersection = nextIntersection;
}
}
const recievingBlock = second.clone();
recievingBlock.selector = joinSelectors(first, second);
recievingBlock.nodes = [];
const difference = different(getDecls(first), getDecls(second));
const filterConflicts = (decls, intersectn) => {
let willNotMove = [];
return decls.reduce((willMove, decl) => {
let intersects = ~intersectn.indexOf(decl);
let prop = decl.split(':')[0];
let base = prop.split('-')[0];
let canMove = difference.every(d => d.split(':')[0] !== base);
if (intersects && canMove && !hasConflicts(prop, willNotMove)) {
willMove.push(decl);
} else {
willNotMove.push(prop);
}
return willMove;
}, []);
};
const containsAllDeclaration = intersectionList => {
return intersectionList.some(declaration => {
return declaration.split(':')[0].toLowerCase() === 'all';
});
};
intersection = filterConflicts(getDecls(first).reverse(), intersection);
intersection = filterConflicts(getDecls(second), intersection);
// Rules with "all" declarations must be on top
if (containsAllDeclaration(intersection)) {
second.parent.insertBefore(first, recievingBlock);
} else {
second.parent.insertBefore(second, recievingBlock);
}
const firstClone = first.clone();
const secondClone = second.clone();
const moveDecl = callback => {
return decl => {
if (~intersection.indexOf(String(decl))) {
callback.call(this, decl);
}
};
};
firstClone.walkDecls(moveDecl(decl => {
decl.remove();
recievingBlock.append(decl);
}));
secondClone.walkDecls(moveDecl(decl => decl.remove()));
const merged = ruleLength(firstClone, recievingBlock, secondClone);
const original = ruleLength(first, second);
if (merged < original) {
first.replaceWith(firstClone);
second.replaceWith(secondClone);
[firstClone, recievingBlock, secondClone].forEach(r => {
if (!r.nodes.length) {
r.remove();
}
});
if (!secondClone.parent) {
return recievingBlock;
}
return secondClone;
} else {
recievingBlock.remove();
return second;
}
}
function selectorMerger(browsers, compatibilityCache) {
let cache = null;
return function (rule) {
// Prime the cache with the first rule, or alternately ensure that it is
// safe to merge both declarations before continuing
if (!cache || !canMerge(rule, cache, browsers, compatibilityCache)) {
cache = rule;
return;
}
// Ensure that we don't deduplicate the same rule; this is sometimes
// caused by a partial merge
if (cache === rule) {
cache = rule;
return;
}
// Merge when declarations are exactly equal
// e.g. h1 { color: red } h2 { color: red }
if (getDecls(rule).join(';') === getDecls(cache).join(';')) {
rule.selector = joinSelectors(cache, rule);
cache.remove();
cache = rule;
return;
}
// Merge when both selectors are exactly equal
// e.g. a { color: blue } a { font-weight: bold }
if (cache.selector === rule.selector) {
const cached = getDecls(cache);
rule.walk(decl => {
if (~cached.indexOf(String(decl))) {
return decl.remove();
}
cache.append(decl);
});
rule.remove();
return;
}
// Partial merge: check if the rule contains a subset of the last; if
// so create a joined selector with the subset, if smaller.
cache = partialMerge(cache, rule);
};
}
exports.default = _postcss2.default.plugin('postcss-merge-rules', () => {
return (css, result) => {
const resultOpts = result.opts || {};
const browsers = (0, _browserslist2.default)(null, {
stats: resultOpts.stats,
path: __dirname,
env: resultOpts.env
});
const compatibilityCache = {};
css.walkRules(selectorMerger(browsers, compatibilityCache));
};
});
module.exports = exports['default'];