trans 0.5.10 → 0.5.13

data/template/node_modules/gulp-minify-css/node_modules/clean-css/lib/properties/scanner.js

@@ -1,20 +0,0 @@
-(function() {
-  var OPEN_BRACE = '{';
-  var SEMICOLON = ';';
-  var COLON = ':';
-
-  var PropertyScanner = function PropertyScanner(data) {
-    this.data = data;
-  };
-
-  PropertyScanner.prototype.nextAt = function(cursor) {
-    var lastColon = this.data.lastIndexOf(COLON, cursor);
-    var lastOpenBrace = this.data.lastIndexOf(OPEN_BRACE, cursor);
-    var lastSemicolon = this.data.lastIndexOf(SEMICOLON, cursor);
-    var startAt = Math.max(lastOpenBrace, lastSemicolon);
-
-    return this.data.substring(startAt + 1, lastColon).trim();
-  };
-
-  module.exports = PropertyScanner;
-})();

data/template/node_modules/gulp-minify-css/node_modules/clean-css/lib/properties/shorthand-compactor.js

@@ -1,244 +0,0 @@
-
-// Compacts the tokens by transforming properties into their shorthand notations when possible
-
-module.exports = (function () {
-  var isHackValue = function (t) { return t.value === '__hack'; };
-
-  var compactShorthands = function(tokens, isImportant, processable, Token) {
-    // Contains the components found so far, grouped by shorthand name
-    var componentsSoFar = { };
-
-    // Initializes a prop in componentsSoFar
-    var initSoFar = function (shprop, last, clearAll) {
-      var found = {};
-      var shorthandPosition;
-
-      if (!clearAll && componentsSoFar[shprop]) {
-        for (var i = 0; i < processable[shprop].components.length; i++) {
-          var prop = processable[shprop].components[i];
-          found[prop] = [];
-
-          if (!(componentsSoFar[shprop].found[prop]))
-            continue;
-
-          for (var ii = 0; ii < componentsSoFar[shprop].found[prop].length; ii++) {
-            var comp = componentsSoFar[shprop].found[prop][ii];
-
-            if (comp.isMarkedForDeletion)
-              continue;
-
-            found[prop].push(comp);
-
-            if (comp.position && (!shorthandPosition || comp.position < shorthandPosition))
-              shorthandPosition = comp.position;
-          }
-        }
-      }
-      componentsSoFar[shprop] = {
-        lastShorthand: last,
-        found: found,
-        shorthandPosition: shorthandPosition
-      };
-    };
-
-    // Adds a component to componentsSoFar
-    var addComponentSoFar = function (token, index) {
-      var shprop = processable[token.prop].componentOf;
-      if (!componentsSoFar[shprop])
-        initSoFar(shprop);
-      if (!componentsSoFar[shprop].found[token.prop])
-        componentsSoFar[shprop].found[token.prop] = [];
-
-      // Add the newfound component to componentsSoFar
-      componentsSoFar[shprop].found[token.prop].push(token);
-
-      if (!componentsSoFar[shprop].shorthandPosition && index) {
-        // If the haven't decided on where the shorthand should go, put it in the place of this component
-        componentsSoFar[shprop].shorthandPosition = index;
-      }
-    };
-
-    // Tries to compact a prop in componentsSoFar
-    var compactSoFar = function (prop) {
-      var i;
-      var componentsCount = processable[prop].components.length;
-
-      // Check basics
-      if (!componentsSoFar[prop] || !componentsSoFar[prop].found)
-        return false;
-
-      // Find components for the shorthand
-      var components = [];
-      var realComponents = [];
-      for (i = 0 ; i < componentsCount; i++) {
-        // Get property name
-        var pp = processable[prop].components[i];
-
-        if (componentsSoFar[prop].found[pp] && componentsSoFar[prop].found[pp].length) {
-          // We really found it
-          var foundRealComp = componentsSoFar[prop].found[pp][0];
-          components.push(foundRealComp);
-          if (foundRealComp.isReal !== false) {
-            realComponents.push(foundRealComp);
-          }
-        } else if (componentsSoFar[prop].lastShorthand) {
-          // It's defined in the previous shorthand
-          var c = componentsSoFar[prop].lastShorthand.components[i].clone(isImportant);
-          components.push(c);
-        } else {
-          // Couldn't find this component at all
-          return false;
-        }
-      }
-
-      if (realComponents.length === 0) {
-        // Couldn't find enough components, sorry
-        return false;
-      }
-
-      if (realComponents.length === componentsCount) {
-        // When all the components are from real values, only allow shorthanding if their understandability allows it
-        // This is the case when every component can override their default values, or when all of them use the same function
-
-        var canOverrideDefault = true;
-        var functionNameMatches = true;
-        var functionName;
-
-        for (var ci = 0; ci < realComponents.length; ci++) {
-          var rc = realComponents[ci];
-
-          if (!processable[rc.prop].canOverride(processable[rc.prop].defaultValue, rc.value)) {
-            canOverrideDefault = false;
-          }
-          var iop = rc.value.indexOf('(');
-          if (iop >= 0) {
-            var otherFunctionName = rc.value.substring(0, iop);
-            if (functionName)
-              functionNameMatches = functionNameMatches && otherFunctionName === functionName;
-            else
-              functionName = otherFunctionName;
-          }
-        }
-
-        if (!canOverrideDefault || !functionNameMatches)
-          return false;
-      }
-
-      // Compact the components into a shorthand
-      var compacted = processable[prop].putTogether(prop, components, isImportant);
-      if (!(compacted instanceof Array)) {
-        compacted = [compacted];
-      }
-
-      var compactedLength = Token.getDetokenizedLength(compacted);
-      var authenticLength = Token.getDetokenizedLength(realComponents);
-
-      if (realComponents.length === componentsCount || compactedLength < authenticLength || components.some(isHackValue)) {
-        compacted[0].isShorthand = true;
-        compacted[0].components = processable[prop].breakUp(compacted[0]);
-
-        // Mark the granular components for deletion
-        for (i = 0; i < realComponents.length; i++) {
-          realComponents[i].isMarkedForDeletion = true;
-        }
-
-        // Mark the position of the new shorthand
-        tokens[componentsSoFar[prop].shorthandPosition].replaceWith = compacted;
-
-        // Reinitialize the thing for further compacting
-        initSoFar(prop, compacted[0]);
-        for (i = 1; i < compacted.length; i++) {
-          addComponentSoFar(compacted[i]);
-        }
-
-        // Yes, we can keep the new shorthand!
-        return true;
-      }
-
-      return false;
-    };
-
-    // Tries to compact all properties currently in componentsSoFar
-    var compactAllSoFar = function () {
-      for (var i in componentsSoFar) {
-        if (componentsSoFar.hasOwnProperty(i)) {
-          while (compactSoFar(i)) { }
-        }
-      }
-    };
-
-    var i, token;
-
-    // Go through each token and collect components for each shorthand as we go on
-    for (i = 0; i < tokens.length; i++) {
-      token = tokens[i];
-      if (token.isMarkedForDeletion) {
-        continue;
-      }
-      if (!processable[token.prop]) {
-        // We don't know what it is, move on
-        continue;
-      }
-      if (processable[token.prop].isShorthand) {
-        // Found an instance of a full shorthand
-        // NOTE: we should NOT mix together tokens that come before and after the shorthands
-
-        if (token.isImportant === isImportant || (token.isImportant && !isImportant)) {
-          // Try to compact what we've found so far
-          while (compactSoFar(token.prop)) { }
-          // Reset
-          initSoFar(token.prop, token, true);
-        }
-
-        // TODO: when the old optimizer is removed, take care of this corner case:
-        //   div{background-color:#111;background-image:url(aaa);background:linear-gradient(aaa);background-repeat:no-repeat;background-position:1px 2px;background-attachment:scroll}
-        //   -> should not be shorthanded / minified at all because the result wouldn't be equivalent to the original in any browser
-      } else if (processable[token.prop].componentOf) {
-        // Found a component of a shorthand
-        if (token.isImportant === isImportant) {
-          // Same importantness
-          token.position = i;
-          addComponentSoFar(token, i);
-        } else if (!isImportant && token.isImportant) {
-          // Use importants for optimalization opportunities
-          // https://github.com/GoalSmashers/clean-css/issues/184
-          var importantTrickComp = new Token(token.prop, token.value, isImportant);
-          importantTrickComp.isIrrelevant = true;
-          importantTrickComp.isReal = false;
-          addComponentSoFar(importantTrickComp);
-        }
-      } else {
-        // This is not a shorthand and not a component, don't care about it
-        continue;
-      }
-    }
-
-    // Perform all possible compactions
-    compactAllSoFar();
-
-    // Process the results - throw away stuff marked for deletion, insert compacted things, etc.
-    var result = [];
-    for (i = 0; i < tokens.length; i++) {
-      token = tokens[i];
-
-      if (token.replaceWith) {
-        for (var ii = 0; ii < token.replaceWith.length; ii++) {
-          result.push(token.replaceWith[ii]);
-        }
-      }
-      if (!token.isMarkedForDeletion) {
-        result.push(token);
-      }
-
-      token.isMarkedForDeletion = false;
-      token.replaceWith = null;
-    }
-
-    return result;
-  };
-
-  return {
-    compactShorthands: compactShorthands
-  };
-
-})();

data/template/node_modules/gulp-minify-css/node_modules/clean-css/lib/properties/token.js

@@ -1,184 +0,0 @@
-
-// Helper for tokenizing the contents of a CSS selector block
-
-module.exports = (function() {
-  var createTokenPrototype = function (processable) {
-    var important = '!important';
-
-    // Constructor for tokens
-    function Token (prop, p2, p3) {
-      this.prop = prop;
-      if (typeof(p2) === 'string') {
-        this.value = p2;
-        this.isImportant = p3;
-      }
-      else {
-        this.value = processable[prop].defaultValue;
-        this.isImportant = p2;
-      }
-    }
-
-    Token.prototype.prop = null;
-    Token.prototype.value = null;
-    Token.prototype.granularValues = null;
-    Token.prototype.components = null;
-    Token.prototype.position = null;
-    Token.prototype.isImportant = false;
-    Token.prototype.isDirty = false;
-    Token.prototype.isShorthand = false;
-    Token.prototype.isIrrelevant = false;
-    Token.prototype.isReal = true;
-    Token.prototype.isMarkedForDeletion = false;
-
-    // Tells if this token is a component of the other one
-    Token.prototype.isComponentOf = function (other) {
-      if (!processable[this.prop] || !processable[other.prop])
-        return false;
-      if (!(processable[other.prop].components instanceof Array) || !processable[other.prop].components.length)
-        return false;
-
-      return processable[other.prop].components.indexOf(this.prop) >= 0;
-    };
-
-    // Clones a token
-    Token.prototype.clone = function (isImportant) {
-      var token = new Token(this.prop, this.value, (typeof(isImportant) !== 'undefined' ? isImportant : this.isImportant));
-      return token;
-    };
-
-    // Creates an irrelevant token with the same prop
-    Token.prototype.cloneIrrelevant = function (isImportant) {
-      var token = Token.makeDefault(this.prop, (typeof(isImportant) !== 'undefined' ? isImportant : this.isImportant));
-      token.isIrrelevant = true;
-      return token;
-    };
-
-    // Creates an array of property tokens with their default values
-    Token.makeDefaults = function (props, important) {
-      return props.map(function(prop) {
-        return new Token(prop, important);
-      });
-    };
-
-    // Parses one CSS property declaration into a token
-    Token.tokenizeOne = function (fullProp) {
-      // Find first colon
-      var colonPos = fullProp.indexOf(':');
-
-      if (colonPos < 0) {
-        // This property doesn't have a colon, it's invalid. Let's keep it intact anyway.
-        return new Token('', fullProp);
-      }
-
-      // Parse parts of the property
-      var prop = fullProp.substr(0, colonPos).trim();
-      var value = fullProp.substr(colonPos + 1).trim();
-      var isImportant = false;
-      var importantPos = value.indexOf(important);
-
-      // Check if the property is important
-      if (importantPos >= 1 && importantPos === value.length - important.length) {
-        value = value.substr(0, importantPos).trim();
-        isImportant = true;
-      }
-
-      // Return result
-      var result = new Token(prop, value, isImportant);
-
-      // If this is a shorthand, break up its values
-      // NOTE: we need to do this for all shorthands because otherwise we couldn't remove default values from them
-      if (processable[prop] && processable[prop].isShorthand) {
-        result.isShorthand = true;
-        result.components = processable[prop].breakUp(result);
-        result.isDirty = true;
-      }
-
-      return result;
-    };
-
-    // Breaks up a string of CSS property declarations into tokens so that they can be handled more easily
-    Token.tokenize = function (input) {
-      // Split the input by semicolons and parse the parts
-      var tokens = input.split(';').map(Token.tokenizeOne);
-      return tokens;
-    };
-
-    // Transforms tokens back into CSS properties
-    Token.detokenize = function (tokens) {
-      // If by mistake the input is not an array, make it an array
-      if (!(tokens instanceof Array)) {
-        tokens = [tokens];
-      }
-
-      var result = '';
-
-      // This step takes care of putting together the components of shorthands
-      // NOTE: this is necessary to do for every shorthand, otherwise we couldn't remove their default values
-      for (var i = 0; i < tokens.length; i++) {
-        var t = tokens[i];
-        if (t.isShorthand && t.isDirty) {
-          var news = processable[t.prop].putTogether(t.prop, t.components, t.isImportant);
-          Array.prototype.splice.apply(tokens, [i, 1].concat(news));
-          t.isDirty = false;
-          i--;
-          continue;
-        }
-
-        if (t.prop)
-          result += t.prop + ':';
-
-        if (t.value)
-          result += t.value;
-
-        if (t.isImportant)
-          result += important;
-
-        result += ';';
-      }
-
-      return result.substr(0, result.length - 1);
-    };
-
-    // Gets the final (detokenized) length of the given tokens
-    Token.getDetokenizedLength = function (tokens) {
-      // If by mistake the input is not an array, make it an array
-      if (!(tokens instanceof Array)) {
-        tokens = [tokens];
-      }
-
-      var result = 0;
-
-      // This step takes care of putting together the components of shorthands
-      // NOTE: this is necessary to do for every shorthand, otherwise we couldn't remove their default values
-      for (var i = 0; i < tokens.length; i++) {
-        var t = tokens[i];
-        if (t.isShorthand && t.isDirty) {
-          var news = processable[t.prop].putTogether(t.prop, t.components, t.isImportant);
-          Array.prototype.splice.apply(tokens, [i, 1].concat(news));
-          t.isDirty = false;
-          i--;
-          continue;
-        }
-
-        if (t.prop) {
-          result += t.prop.length + 1;
-        }
-        if (t.value) {
-          result += t.value.length;
-        }
-        if (t.isImportant) {
-          result += important.length;
-        }
-      }
-
-      return result;
-    };
-
-    return Token;
-  };
-
-  return {
-    createTokenPrototype: createTokenPrototype
-  };
-
-})();