Graybyt3 Was Here

Linux vps-4656817-x.dattaweb.com 5.14.0-570.33.2.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Aug 14 07:37:35 EDT 2025 x86_64
Apache
200.58.107.103

File Name : merge-into-shorthands.js

var everyValuesPair = require('./every-values-pair');
var hasInherit = require('./has-inherit');
var hasSameValues = require('./has-same-values');
var populateComponents = require('./populate-components');

var configuration = require('../../configuration');
var deepClone = require('../../clone').deep;
var restoreWithComponents = require('../restore-with-components');

var restoreFromOptimizing = require('../../restore-from-optimizing');
var wrapSingle = require('../../wrap-for-optimizing').single;

var serializeBody = require('../../../writer/one-time').body;
var Token = require('../../../tokenizer/token');

function mergeIntoShorthands(properties, validator) {
  var candidates = {};
  var descriptor;
  var componentOf;
  var property;
  var i, l;
  var j, m;

// there is no shorthand property made up of less than 3 longhands
  if (properties.length < 3) {
    return;
  }

for (i = 0, l = properties.length; i < l; i++) {
    property = properties[i];
    descriptor = configuration[property.name];

if (property.dynamic) {
      continue;
    }

if (property.unused) {
      continue;
    }

if (property.hack) {
      continue;
    }

if (property.block) {
      continue;
    }

if (descriptor && descriptor.singleTypeComponents && !hasSameValues(property)) {
      continue;
    }

invalidateOrCompact(properties, i, candidates, validator);

if (descriptor && descriptor.componentOf) {
      for (j = 0, m = descriptor.componentOf.length; j < m; j++) {
        componentOf = descriptor.componentOf[j];

candidates[componentOf] = candidates[componentOf] || {};
        candidates[componentOf][property.name] = property;
      }
    }
  }

invalidateOrCompact(properties, i, candidates, validator);
}

function invalidateOrCompact(properties, position, candidates, validator) {
  var invalidatedBy = properties[position];
  var shorthandName;
  var shorthandDescriptor;
  var candidateComponents;
  var replacedCandidates = [];
  var i;

for (shorthandName in candidates) {
    if (undefined !== invalidatedBy && shorthandName == invalidatedBy.name) {
      continue;
    }

shorthandDescriptor = configuration[shorthandName];
    candidateComponents = candidates[shorthandName];
    if (invalidatedBy && invalidates(candidates, shorthandName, invalidatedBy)) {
      delete candidates[shorthandName];
      continue;
    }

if (shorthandDescriptor.components.length > Object.keys(candidateComponents).length) {
      continue;
    }

if (mixedImportance(candidateComponents)) {
      continue;
    }

if (!overridable(candidateComponents, shorthandName, validator)) {
      continue;
    }

if (!mergeable(candidateComponents)) {
      continue;
    }

if (mixedInherit(candidateComponents)) {
      replaceWithInheritBestFit(properties, candidateComponents, shorthandName, validator);
    } else {
      replaceWithShorthand(properties, candidateComponents, shorthandName, validator);
    }

replacedCandidates.push(shorthandName);
  }

for (i = replacedCandidates.length - 1; i >= 0; i--) {
    delete candidates[replacedCandidates[i]];
  }
}

function invalidates(candidates, shorthandName, invalidatedBy) {
  var shorthandDescriptor = configuration[shorthandName];
  var invalidatedByDescriptor = configuration[invalidatedBy.name];
  var componentName;

if ('overridesShorthands' in shorthandDescriptor && shorthandDescriptor.overridesShorthands.indexOf(invalidatedBy.name) > -1) {
    return true;
  }

if (invalidatedByDescriptor && 'componentOf' in invalidatedByDescriptor) {
    for (componentName in candidates[shorthandName]) {
      if (invalidatedByDescriptor.componentOf.indexOf(componentName) > -1) {
        return true;
      }
    }
  }

return false;
}

function mixedImportance(components) {
  var important;
  var componentName;

for (componentName in components) {
    if (undefined !== important && components[componentName].important != important) {
      return true;
    }

important = components[componentName].important;
  }

return false;
}

function overridable(components, shorthandName, validator) {
  var descriptor = configuration[shorthandName];
  var newValuePlaceholder = [
    Token.PROPERTY,
    [Token.PROPERTY_NAME, shorthandName],
    [Token.PROPERTY_VALUE, descriptor.defaultValue]
  ];
  var newProperty = wrapSingle(newValuePlaceholder);
  var component;
  var mayOverride;
  var i, l;

populateComponents([newProperty], validator, []);

for (i = 0, l = descriptor.components.length; i < l; i++) {
    component = components[descriptor.components[i]];
    mayOverride = configuration[component.name].canOverride || sameValue;

if (!everyValuesPair(mayOverride.bind(null, validator), newProperty.components[i], component)) {
      return false;
    }
  }

return true;
}

function sameValue(_validator, value1, value2) {
  return value1 === value2;
}

function mergeable(components) {
  var lastCount = null;
  var currentCount;
  var componentName;
  var component;
  var descriptor;
  var values;

for (componentName in components) {
    component = components[componentName];
    descriptor = configuration[componentName];

if (!('restore' in descriptor)) {
      continue;
    }

restoreFromOptimizing([component.all[component.position]], restoreWithComponents);
    values = descriptor.restore(component, configuration);

currentCount = values.length;

if (lastCount !== null && currentCount !== lastCount) {
      return false;
    }

lastCount = currentCount;
  }

return true;
}

function mixedInherit(components) {
  var componentName;
  var lastValue = null;
  var currentValue;

for (componentName in components) {
    currentValue = hasInherit(components[componentName]);

if (lastValue !== null && lastValue !== currentValue) {
      return true;
    }

lastValue = currentValue;
  }

return false;
}

function replaceWithInheritBestFit(properties, candidateComponents, shorthandName, validator) {
  var viaLonghands = buildSequenceWithInheritLonghands(candidateComponents, shorthandName, validator);
  var viaShorthand = buildSequenceWithInheritShorthand(candidateComponents, shorthandName, validator);
  var longhandTokensSequence = viaLonghands[0];
  var shorthandTokensSequence = viaShorthand[0];
  var isLonghandsShorter = serializeBody(longhandTokensSequence).length < serializeBody(shorthandTokensSequence).length;
  var newTokensSequence = isLonghandsShorter ? longhandTokensSequence : shorthandTokensSequence;
  var newProperty = isLonghandsShorter ? viaLonghands[1] : viaShorthand[1];
  var newComponents = isLonghandsShorter ? viaLonghands[2] : viaShorthand[2];
  var lastComponent = candidateComponents[Object.keys(candidateComponents).pop()];
  var all = lastComponent.all;
  var insertAt = lastComponent.position;
  var componentName;
  var oldComponent;
  var newComponent;
  var newToken;

newProperty.position = insertAt;
  newProperty.shorthand = true;
  newProperty.important = lastComponent.important;
  newProperty.multiplex = false;
  newProperty.dirty = true;
  newProperty.all = all;
  newProperty.all[insertAt] = newTokensSequence[0];

properties.splice(insertAt, 1, newProperty);

for (componentName in candidateComponents) {
    oldComponent = candidateComponents[componentName];
    oldComponent.unused = true;

newProperty.multiplex = newProperty.multiplex || oldComponent.multiplex;

if (oldComponent.name in newComponents) {
      newComponent = newComponents[oldComponent.name];
      newToken = findTokenIn(newTokensSequence, componentName);

newComponent.position = all.length;
      newComponent.all = all;
      newComponent.all.push(newToken);

properties.push(newComponent);
    }
  }
}

function buildSequenceWithInheritLonghands(components, shorthandName, validator) {
  var tokensSequence = [];
  var inheritComponents = {};
  var nonInheritComponents = {};
  var descriptor = configuration[shorthandName];
  var shorthandToken = [
    Token.PROPERTY,
    [Token.PROPERTY_NAME, shorthandName],
    [Token.PROPERTY_VALUE, descriptor.defaultValue]
  ];
  var newProperty = wrapSingle(shorthandToken);
  var component;
  var longhandToken;
  var newComponent;
  var nameMetadata;
  var i, l;

populateComponents([newProperty], validator, []);

for (i = 0, l = descriptor.components.length; i < l; i++) {
    component = components[descriptor.components[i]];

if (hasInherit(component)) {
      longhandToken = component.all[component.position].slice(0, 2);
      Array.prototype.push.apply(longhandToken, component.value);
      tokensSequence.push(longhandToken);

newComponent = deepClone(component);
      newComponent.value = inferComponentValue(components, newComponent.name);

newProperty.components[i] = newComponent;
      inheritComponents[component.name] = deepClone(component);
    } else {
      newComponent = deepClone(component);
      newComponent.all = component.all;
      newProperty.components[i] = newComponent;

nonInheritComponents[component.name] = component;
    }
  }

newProperty.important = components[Object.keys(components).pop()].important;

nameMetadata = joinMetadata(nonInheritComponents, 1);
  shorthandToken[1].push(nameMetadata);

restoreFromOptimizing([newProperty], restoreWithComponents);

shorthandToken = shorthandToken.slice(0, 2);
  Array.prototype.push.apply(shorthandToken, newProperty.value);

tokensSequence.unshift(shorthandToken);

return [tokensSequence, newProperty, inheritComponents];
}

function inferComponentValue(components, propertyName) {
  var descriptor = configuration[propertyName];

if ('oppositeTo' in descriptor) {
    return components[descriptor.oppositeTo].value;
  }
  return [[Token.PROPERTY_VALUE, descriptor.defaultValue]];
}

function joinMetadata(components, at) {
  var metadata = [];
  var component;
  var originalValue;
  var componentMetadata;
  var componentName;

for (componentName in components) {
    component = components[componentName];
    originalValue = component.all[component.position];
    componentMetadata = originalValue[at][originalValue[at].length - 1];

Array.prototype.push.apply(metadata, componentMetadata);
  }

return metadata.sort(metadataSorter);
}

function metadataSorter(metadata1, metadata2) {
  var line1 = metadata1[0];
  var line2 = metadata2[0];
  var column1 = metadata1[1];
  var column2 = metadata2[1];

if (line1 < line2) {
    return -1;
  } if (line1 === line2) {
    return column1 < column2 ? -1 : 1;
  }
  return 1;
}

function buildSequenceWithInheritShorthand(components, shorthandName, validator) {
  var tokensSequence = [];
  var inheritComponents = {};
  var nonInheritComponents = {};
  var descriptor = configuration[shorthandName];
  var shorthandToken = [
    Token.PROPERTY,
    [Token.PROPERTY_NAME, shorthandName],
    [Token.PROPERTY_VALUE, 'inherit']
  ];
  var newProperty = wrapSingle(shorthandToken);
  var component;
  var longhandToken;
  var nameMetadata;
  var valueMetadata;
  var i, l;

populateComponents([newProperty], validator, []);

for (i = 0, l = descriptor.components.length; i < l; i++) {
    component = components[descriptor.components[i]];

if (hasInherit(component)) {
      inheritComponents[component.name] = component;
    } else {
      longhandToken = component.all[component.position].slice(0, 2);
      Array.prototype.push.apply(longhandToken, component.value);
      tokensSequence.push(longhandToken);

nonInheritComponents[component.name] = deepClone(component);
    }
  }

nameMetadata = joinMetadata(inheritComponents, 1);
  shorthandToken[1].push(nameMetadata);

valueMetadata = joinMetadata(inheritComponents, 2);
  shorthandToken[2].push(valueMetadata);

tokensSequence.unshift(shorthandToken);

return [tokensSequence, newProperty, nonInheritComponents];
}

function findTokenIn(tokens, componentName) {
  var i, l;

for (i = 0, l = tokens.length; i < l; i++) {
    if (tokens[i][1][1] == componentName) {
      return tokens[i];
    }
  }
}

function replaceWithShorthand(properties, candidateComponents, shorthandName, validator) {
  var descriptor = configuration[shorthandName];
  var nameMetadata;
  var valueMetadata;
  var newValuePlaceholder = [
    Token.PROPERTY,
    [Token.PROPERTY_NAME, shorthandName],
    [Token.PROPERTY_VALUE, descriptor.defaultValue]
  ];
  var all;
  var insertAt = inferInsertAtFrom(properties, candidateComponents, shorthandName);

var newProperty = wrapSingle(newValuePlaceholder);
  newProperty.shorthand = true;
  newProperty.dirty = true;
  newProperty.multiplex = false;

populateComponents([newProperty], validator, []);

for (var i = 0, l = descriptor.components.length; i < l; i++) {
    var component = candidateComponents[descriptor.components[i]];

newProperty.components[i] = deepClone(component);
    newProperty.important = component.important;
    newProperty.multiplex = newProperty.multiplex || component.multiplex;

all = component.all;
  }

for (var componentName in candidateComponents) {
    candidateComponents[componentName].unused = true;
  }

nameMetadata = joinMetadata(candidateComponents, 1);
  newValuePlaceholder[1].push(nameMetadata);

valueMetadata = joinMetadata(candidateComponents, 2);
  newValuePlaceholder[2].push(valueMetadata);

newProperty.position = insertAt;
  newProperty.all = all;
  newProperty.all[insertAt] = newValuePlaceholder;

properties.splice(insertAt, 1, newProperty);
}

function inferInsertAtFrom(properties, candidateComponents, shorthandName) {
  var candidateComponentNames = Object.keys(candidateComponents);
  var firstCandidatePosition = candidateComponents[candidateComponentNames[0]].position;
  var lastCandidatePosition = candidateComponents[candidateComponentNames[candidateComponentNames.length - 1]].position;

if (shorthandName == 'border' && traversesVia(properties.slice(firstCandidatePosition, lastCandidatePosition), 'border-image')) {
    return firstCandidatePosition;
  }
  return lastCandidatePosition;
}

function traversesVia(properties, propertyName) {
  for (var i = properties.length - 1; i >= 0; i--) {
    if (properties[i].name == propertyName) {
      return true;
    }
  }

return false;
}

module.exports = mergeIntoShorthands;

System Information
*ReClick For Close
File : BlackDragon /acciones/about.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	bienesraicess/bienesraicess	0755	2025-09-01 07:15:51
..	dir	-	bienesraicess/bienesraicess	0755	2025-09-01 07:15:51
every-values-pair.js	file	780 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
find-component-in.js	file	950 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
has-inherit.js	file	202 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
has-same-values.js	file	271 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
has-unset.js	file	196 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
is-component-of.js	file	691 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
is-mergeable-shorthand.js	file	256 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
merge-into-shorthands.js	file	13.97 KB	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
optimize.js	file	1.45 KB	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
override-properties.js	file	14.44 KB	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
overrides-non-component-shorthand.js	file	359 B	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51
populate-components.js	file	1.82 KB	bienesraicess/bienesraicess	0644	2025-09-01 07:15:51