Parse the `str` url with fast-path short-cut.

@param {string} str
@return {Object}
@private
777806
function fastparse (str) {
  if (typeof str !== 'string' || str.charCodeAt(0) !== 0x2f /* / */) {
    return parse(str)
  }

  var pathname = str
  var query = null
  var search = null

  // This takes the regexp from https://github.com/joyent/node/pull/7878
  // Which is /^(\/[^?#\s]*)(\?[^#\s]*)?$/
  // And unrolls it into a for loop
  for (var i = 1; i < str.length; i++) {
    switch (str.charCodeAt(i)) {
      case 0x3f: /* ?  */
        if (search === null) {
          pathname = str.substring(0, i)
          query = str.substring(i + 1)
          search = str.substring(i)
        }
        break
      case 0x09: /* \t */
      case 0x0a: /* \n */
      case 0x0c: /* \f */
      case 0x0d: /* \r */
      case 0x20: /*    */
      case 0x23: /* #  */
      case 0xa0:
      case 0xfeff:
        return parse(str)
    }
  }

  var url = Url !== undefined
    ? new Url()
    : {}

  url.path = str
  url.href = str
  url.pathname = pathname

  if (search !== null) {
    url.query = query
    url.search = search
  }

  return url
}
1051027
function parsePart( str ){

    if ( str ){
        return getFullLines( str ).reduce( getDict, {} );
    } else {
        return {};
    }

    function getDict( r, line ){

        if ( line.indexOf( ":" ) === -1 ){
            r[line] =           line;
        } else {
            line =              line.split( ":" );
            r[line.shift().trim()] =   line.join( ":" ).trim();
        }

        return r;
    }///
}
417943
function parseArray(str) {
  return R.filter(R.identity, str.split(',').map(R.invoker(0, 'trim')))
}
1084500
function (str) {

        if (!str || !str.length || str.length < 2) {
            return null;
        }

        var jsonStr = str.substring(1, str.length - 1);

        return JSON.parse(jsonStr);
    }
31829
function(str) {
      if (typeof str !== 'string') {
        str = this.content;
      }
      if (typeof str !== 'string') return '';
      str = str.replace(/(<([^>]+)>)/g, '');
      return str.trim();
    }
1184695
function _convertUrlsToLinks(str) {
    return str.replace(URL_REG_EXP, function(match, url) {
      var punctuation = (url.match(TRAILING_CHAR_REG_EXP) || [])[1] || "",
          opening     = BRACKETS[punctuation];
      url = url.replace(TRAILING_CHAR_REG_EXP, "");

      if (url.split(opening).length > url.split(punctuation).length) {
        url = url + punctuation;
        punctuation = "";
      }
      var realUrl    = url,
          displayUrl = url;
      if (url.length > MAX_DISPLAY_LENGTH) {
        displayUrl = displayUrl.substr(0, MAX_DISPLAY_LENGTH) + "...";
      }
      // Add http prefix if necessary
      if (realUrl.substr(0, 4) === "www.") {
        realUrl = "http://" + realUrl;
      }

      return '<a href="' + realUrl + '">' + displayUrl + '</a>' + punctuation;
    });
  }
538609
function(str) {
    return (_.startsWith(str, '"') && _.endsWith(str, '"') && !_.includes(_.trim(str, '"'), '"')) ||
      (_.startsWith(str, "'") && _.endsWith(str, "'") && !_.includes(_.trim(str, "'"), "'"))
  }
1188080
function parse(url) {
  ['?', '#'].forEach(function(separator) {
    var index = url.indexOf(separator);
    if (index !== -1) url = url.substring(0, index);
  });
  return url;
}
1324526
function(str){
            str = (str || "").toString();
            str = str.replace(/\=(?:\r?\n|$)/g, "");
            var str2 = "";
            for(var i=0, len = str.length; i<len; i++){
                chr = str.charAt(i);
                if(chr == "=" && (hex = str.substr(i+1, 2)) && /[\da-fA-F]{2}/.test(hex)){
                    str2 += String.fromCharCode(parseInt(hex,16));
                    i+=2;
                    continue;
                }
                str2 += chr;
            }
            return str2;
        }
801672
def parse_str(self, s):
        
        root = ET.fromstring(s)
        return self._parse(root)
398045
function parse (str) {
	var params = str.split('_')
	return {
		float: params[0] === 'F',
		signed: params[0] === 'S',
		bitDepth: parseInt(params[1]),
		byteOrder: params[2],
		channels: parseInt(params[3]),
		sampleRate: parseInt(params[4]),
		interleaved: params[5] === 'I'
	}
}
859830
function params (str){
      return reduce(str.split(/ *; */), function (obj, str){
        var parts = str.split(/ *= */),
            key = parts.shift(),
            val = parts.shift()

        if (key && val) obj[key] = val
        return obj
      }, {})
    }
243319
function parse(arg)
{
  try{
    var url = urllib.parse(arg, true);
  }catch(E){
    return false;
  }

  // paths is always an array
  if(!url.query.paths) url.query.paths = [];
  if(!Array.isArray(url.query.paths)) url.query.paths = [url.query.paths];
  
  // parse any paths
  url.paths = [];
  url.query.paths.forEach(function(epath){
    try{
      var path = JSON.parse(hashname.base32.decode(epath));
      if(typeof path == 'object' && typeof path.type == 'string') url.paths.push(path);
    }catch(E){};
  });

  // parse any csid keys
  url.keys = {};
  Object.keys(url.query).forEach(function(id){
    if(id.length != 4 || id.substr(0,2) != 'cs') return;
    url.keys[id.substr(2)] = url.query[id];
  });
  
  // parse any fragment
  if(url.hash) url.fragment = hashname.base32.decode(url.hash.substr(1));
  
  // add formatting wrapper
  url.encode = function()
  {
    // delete these to force lib to make new
    delete url.search;
    delete url.href;
    if(url.query.paths.length == 0) delete url.query.paths; // dumb node bug
    return urllib.format(url);
  }
  
  return url;
}
376326
function parse_info(str){
	var sq = str.split('&'),
		u = {};
	for (var i = 0; i < sq.length; i++) {
		var kv = sq[i].split('=');
		u[kv[0]] = kv[1];
	}
	return u;
}
553626
function stringToBuffer (str) {
  str = cleanPath(str)
  const a = stringToStringTuples(str)
  const b = stringTuplesToTuples(a)

  return tuplesToBuffer(b)
}
238474
function parseBinaryString(str) {
                var len = str.length / 32;
                var ans = new Array(len);
                for (var i = 0; i < len; i++) {
                    ans[i] = parseInt(str.substr(i*32, 32), 2) | 0;
                }
                return ans;
            }
31997
function getStart (str) {
  var ret = null
  var match = /[0-9]+,[0-9]+,.*/.test(str)
  if (!match) {
    return null
  }
  var a = str.split(',')
  if (a && a[0]) {
    var end = a[0]
    ret = parseInt(end)
    return ret
  } else {
    return null
  }
  if (isNaN(ret)) {
    return null
  }
  return ret
}