/* jscs: disable requireCamelCaseOrUpperCaseIdentifiers /* eslint-disable camelcase
2955
function Stats(dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atim_msec, mtim_msec, ctim_msec, birthtim_msec, path) {
        /* jshint maxparams: 4 */
        if (arguments.length === 1 && typeof arguments[0] === 'object') {
            return Stats.create(arguments[0]);
        }
        if (!Stats.is(this)) {
            return new Stats(dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atim_msec, mtim_msec, ctim_msec,
                birthtim_msec, path);
        }

        var entry = path;
        this.getEntry = function () {
            return entry;
        };

        /* ID of device containing file */
        this.dev = dev;
        /* inode number */
        this.mode = mode;
        /* protection */
        this.nlink = nlink;
        /* number of hard links */
        this.uid = uid;
        /* user ID of owner */
        this.gid = gid;
        /* group ID of owner */
        this.rdev = rdev;
        /* device ID (if special file) */
        this.blksize = blksize;
        /* total size, in bytes */
        this.ino = ino;
        /* blocksize for file system I/O */
        this.size = size;
        /* number of 512B blocks allocated */
        this.blocks = blocks;
        /* time of last access */
        this.atime = new Date(atim_msec);
        /* time of last modification */
        this.mtime = new Date(mtim_msec);
        /* time of last status change */
        this.ctime = new Date(ctim_msec);
        this.birthtime = new Date(birthtim_msec);
    }
515610
function transformKeysToCamelCase (obj) {
  var camelKey;
  var key;
  for (key in obj) {
    camelKey = toCamelCase(key);
    if (key === camelKey) { continue; }
    obj[camelKey] = obj[key];
    delete obj[key];
  }
  return obj;
}
220999
function camelize(s) {
    return s.replace(STRING_CAMELIZE, function (match, separator, chr) {
        return chr.toUpperCase();
    }).replace(/^([A-Z])/, function (match) {
        return match.toLowerCase();
    });
}
177916
function preHandleSrc (cssSrc) {

            /* 
             * fix like: .a{ filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#e6529dda', endColorstr='#e6529dda', GradientType=0)\9;}
             * which has two semicolon( : ) will cause parse error.
             */
            cssSrc = cssSrc.replace(/progid(\s)?:(\s)?/g, '#tidy1#');

            /*
             * fix absolute url path like: 
             * .a { background: url("http://www.qq.com/one.png");} 
             *
             */

            cssSrc = cssSrc.replace(/:\/\//g, '#tidy2#');

            /*
             * fix base64 url like: 
             * .a { background: url("data:image/png;base64,iVBOMVEX///////////////+g0jAqu8zdII=");} 
             *
             */
            cssSrc = cssSrc.replace(/data[\s\S]+?\)/g, function(match){
                match = match.replace(/:/g, '#tidy3#');
                match = match.replace(/;/g, '#tidy4#');
                match = match.replace(/\//g, '#tidy5#');
                return match;
            });

            /*
             * fix multiple line comment include single comment //
             * eg: / * sth // another * /
             */
            cssSrc = cssSrc.replace(/\/\*[\s\S]+?\*\//g, function(match){
                // handle single comment //
                match = match.replace(/\/\//g, '#tidy6#');
                return  match;
            });

            /*
             * fix single comment like:  // something 
             * It can't works in IE, and will cause parse error
             * update: handle single line for compressive case
             */
            cssSrc = cssSrc.replace(/(^|[^:|'|"|\(])\/\/.+?(?=\n|\r|$)/g, function(match){
                // Handle compressive file
                if (match.indexOf('{') === -1 || match.indexOf('}') === -1) {
                    var targetMatch;

                    //handle first line
                    if (match.charAt(0) !== '/' ) {
                        // remove first string and / and \ 
                        targetMatch = match.substr(1).replace(/\\|\//g, '');
                        return match.charAt(0) + '/*' + targetMatch + '*/';
                    } else {
                        targetMatch = match.replace(/\\|\//g, '');
                        return '/*' + targetMatch + '*/';
                    }
                } else {
                    throw new Error('There maybe some single comment // in this file.');
                }
            });

            return cssSrc;
        }
93275
function camelCase(text) {
    text = text || '';
    return text.replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
        return index === 0 ? letter.toLowerCase() : letter.toUpperCase();
    }).replace(/\s+/g, '');
}
458200
function snakeCase(str) {
            return camelCase(str).replace(reCamelCase, function (all, letter) {
                return "-" + letter.toLowerCase();
            });
        }
1183134
function TRANSITION_PROPERTY_VALIDATOR(v) {
  v = (v || '').toString()
  v = util.hyphenedToCamelCase(v)

  for (var prop in validatorMap) {
    if (prop === v) {
      return {value: v}
    }
  }

  return {
    value: null,
    reason: function reason(k, v, result) {
      return 'ERROR: property value `' + v + '` is not supported for `' + util.camelCaseToHyphened(k) + '` (only css property is valid)'
    }
  }
}
641020
function transformCase(str, transFn = 'pascalCase') {
  if (!allowedNameTransforms.hasOwnProperty(transFn)) {
    const message = `Invalid transform, allowed transform functions are:\n
    ${Object.keys(allowedNameTransforms).join(', ')}]`;
    throw new Error(message);
  }
  return changeCase[transFn](str);
}
1277268
function () {
    var id = "";
    var index = 0;
    var type, char;

    function isNonAsciiIdentifierStart(code) {
      return nonAsciiIdentifierStartTable.indexOf(code) > -1;
    }

    function isNonAsciiIdentifierPart(code) {
      return isNonAsciiIdentifierStart(code) || nonAsciiIdentifierPartTable.indexOf(code) > -1;
    }

    function isHexDigit(str) {
      return (/^[0-9a-fA-F]$/).test(str);
    }

    var readUnicodeEscapeSequence = function () {
      /*jshint validthis:true */
      index += 1;

      if (this.peek(index) !== "u") {
        return null;
      }

      var ch1 = this.peek(index + 1);
      var ch2 = this.peek(index + 2);
      var ch3 = this.peek(index + 3);
      var ch4 = this.peek(index + 4);
      var code;

      if (isHexDigit(ch1) && isHexDigit(ch2) && isHexDigit(ch3) && isHexDigit(ch4)) {
        code = parseInt(ch1 + ch2 + ch3 + ch4, 16);

        if (asciiIdentifierPartTable[code] || isNonAsciiIdentifierPart(code)) {
          index += 5;
          return "\\u" + ch1 + ch2 + ch3 + ch4;
        }

        return null;
      }

      return null;
    }.bind(this);

    var getIdentifierStart = function () {
      /*jshint validthis:true */
      var chr = this.peek(index);
      var code = chr.charCodeAt(0);

      if (code === 92) {
        return readUnicodeEscapeSequence();
      }

      if (code < 128) {
        if (asciiIdentifierStartTable[code]) {
          index += 1;
          return chr;
        }

        return null;
      }

      if (isNonAsciiIdentifierStart(code)) {
        index += 1;
        return chr;
      }

      return null;
    }.bind(this);

    var getIdentifierPart = function () {
      /*jshint validthis:true */
      var chr = this.peek(index);
      var code = chr.charCodeAt(0);

      if (code === 92) {
        return readUnicodeEscapeSequence();
      }

      if (code < 128) {
        if (asciiIdentifierPartTable[code]) {
          index += 1;
          return chr;
        }

        return null;
      }

      if (isNonAsciiIdentifierPart(code)) {
        index += 1;
        return chr;
      }

      return null;
    }.bind(this);

    char = getIdentifierStart();
    if (char === null) {
      return null;
    }

    id = char;
    for (;;) {
      char = getIdentifierPart();

      if (char === null) {
        break;
      }

      id += char;
    }

    switch (id) {
    case "true":
    case "false":
      type = Token.BooleanLiteral;
      break;
    case "null":
      type = Token.NullLiteral;
      break;
    default:
      type = Token.Identifier;
    }

    return {
      type: type,
      value: id
    };
  }
409465
function _toCamelCase(str) {
  var newString = '';
  var insideParens = false;
  newString += str[0].toLowerCase();
  for (var i = 1; i < str.length; i++) {
    var char = str[i];
    switch (char) {
      case ')':
      case '_':
        break;
      case '(':
        insideParens = true;
        break;
      default:
        if (insideParens) {
          insideParens = false;
          newString += char.toUpperCase();
        } else {
          newString += char;
        }
        break;
    }
  }

  return newString;
}
137353
function unescapeHtml(s) {
            if (_toString.call(s) != "[object String]") return s;
            if (!s) return "";
            return s.replace(/(&lt;)|(&gt;)|(&amp;)|(&quot;)/gm, function (match) {
                switch (match) {
                    case "&lt;":
                        return "<";
                    case "&gt;":
                        return ">";
                    case "&amp;":
                        return "&";
                    case "&quot;":
                        return "\"";
                    default:
                        return match;
                }
            });
        }
304935
function checkCamelCase(idNode) {
  var reported = false;
  var fakeContext = {
    report: function() { reported = true; },
    options: []
  };
  camelcase(fakeContext).Identifier(idNode);  // eslint-disable-line new-cap
  return !reported;
}
90893
public static String underscoreSeparated(String camelCaseName) {
        return StringUtils.lowerCase(
                Arrays.stream(StringUtils.split(camelCaseName, SubFacet.SEPARATOR))
                        .flatMap(component -> Arrays.stream(StringUtils.splitByCharacterTypeCamelCase(component)))
                        .collect(Collectors.joining("_")));
    }
991286
function addCamelCasedVersion(obj) {
  const regExp = /(-[a-z])/g
  const replace = str => str[1].toUpperCase()
  const newObj = {}
  for (const key in obj) {
    newObj[key] = obj[key]
    newObj[key.replace(regExp, replace)] = obj[key]
  }
  return newObj
}
348414
function dashToCamelCase(dashCase) {
    if (!dashCase) { return dashCase; }

    var parts = dashCase.split('-');
    var camelCase = parts[0];
    var part;

    for (var i = 1; i < parts.length; i++) {
        part = parts[i];
        camelCase += part.substring(0, 1).toUpperCase() + part.substring(1);
    }

    return camelCase;
}
1352042
function camelize(string) {
  return string.replace(/-+(.)?/g, function(match, character) {
    return character ? character.toUpperCase() : '';
  });
}
1039801
function stringToCamelCase (str) {
  return str.toLowerCase().replace(rCamel, function (match, group1) {
    return group1.toUpperCase()
  })
}