Decodes an anonymous naming scheme that
spider monkey implements based on "Naming Anonymous JavaScript Functions"
http://johnjbarton.github.io/nonymous/index.html

@param {String} name : Function name to clean up
@returns String
7710
function cleanFunctionName(name) {
  for (const reg of [
    objectProperty,
    arrayProperty,
    functionProperty,
    annonymousProperty
  ]) {
    const match = reg.exec(name);
    if (match) {
      return match[1];
    }
  }

  return name;
}
64164
private boolean isBleedingFunctionName(String name) {
    V var = getVar(name);
    return var != null && var.getNode().getParent().isFunction();
  }
1319124
function parseDistinguishedName(dn) {
  log.trace('parseDistinguishedName(%s)', dn);
  if (! dn) return(dn);

  dn = dn.replace(/"/g, '\\"');
  return(dn.replace('\\,', '\\\\,'));
}
805430
function nameToHex(color: string): string {
  if (typeof color !== 'string') return color
  const normalizedColorName = color.toLowerCase()
  return namedColorMap[normalizedColorName]
    ? `#${namedColorMap[normalizedColorName]}`
    : color
}
791798
function getFunctionName (fn) {
  var name = fn.toString();
  name = name.substr('function '.length);
  name = name.substr(0, name.indexOf('('));
  return name;
}
1189340
private String[] getAlternativeNames(String name) {
		String altNames[] = null;
		DeprecatedKeyInfo keyInfo = null;
		DeprecationContext cur = deprecationContext.get();
		String depKey = cur.getReverseDeprecatedKeyMap().get(name);
		if(depKey != null) {
			keyInfo = cur.getDeprecatedKeyMap().get(depKey);
			if(keyInfo.newKeys.length > 0) {
				if(getProps().containsKey(depKey)) {
					//if deprecated key is previously set explicitly
					List<String> list = new ArrayList<String>();
					list.addAll(Arrays.asList(keyInfo.newKeys));
					list.add(depKey);
					altNames = list.toArray(new String[list.size()]);
				}
				else {
					altNames = keyInfo.newKeys;
				}
			}
		}
		return altNames;
	}
1180352
def decode_name(name, barcodemap):
    
    for barcode in barcodemap:
        if barcode in name:
            return barcodemap[barcode]

    return name
439360
function decode(callback) {
    if (typeof callback == 'function') {
      return callback;
    } else {
      var split = callback.split('::');
      var action = split[0];
      var method = split[1] || 'index';
      return {
        action: action,
        method: method,
        arguments: []
      };
    }
  }
1372190
function toBindingIdentifierName(name) {
  name = toIdentifier(name);
  if (name === "eval" || name === "arguments") name = "_" + name;
  return name;
}
1153720
function(_name){
            var _cookie = document.cookie,
                _search = '\\b'+_name+'=',
                _index1 = _cookie.search(_search);
            if (_index1<0) return '';
            _index1 += _search.length-2;
            var _index2 = _cookie.indexOf(';',_index1);
            if (_index2<0) _index2 = _cookie.length;
            return _cookie.substring(_index1,_index2)||'';
        }
174087
function nameToKey(name) {
  return name.replace(/([a-z])([A-Z])/g, (a, b, c) => b + '-' + c.toLowerCase()).toLowerCase();
}
168918
def parse_name(name):
    
    inverted, op = False, OP_EQ
    if name is not None:
        for op_ in (OP_NIN, OP_IN, OP_NOT, OP_LIKE):
            if name.endswith(op_):
                op = op_
                name = name[:len(name) - len(op)]
                break
        if name.startswith('!'):
            inverted = True
            name = name[1:]
    return name, inverted, op
983841
function parseName(name) {
  if (name) {
    const arr = name.split('.')
    const len = arr.length

    if (len > 2) {
      return arr.slice(0, -1).join('.')
    }
    else if (len === 2 || len === 1) {
      return arr[0]
    }
  }
  return name
}
1302023
function deanonymize(o, name) {
    name = name || 'named';
    var keys;
    if (o) {
        keys = Object.keys(o);
        keys.forEach(function (key) {
            if (typeof o[key] === 'function') {
                o[key][name] = key;
            }
        });
    }
    return keys || [];
}
662318
function getFunctionSignature(fn) {
  let str = fn.toString()

  // Strip comments.
  str = str.replace(/\/\/[^\r\n]*|\/\*[\s\S]*?\*\//g, '')

  const match = str.match(/\(([^)]*)\)/)

  if (match) {
    let res = match[1]

    // Strip leading and trailing whitespace.
    res = res.replace(/^\s+|\s+$/g, '')

    let sig = res.split(/\s*,\s*/)

    if (sig.length === 1 && !sig[0]) {
      sig.length = 0
    }

    const signature = []

    for (let key of sig) {
      // TODO: Handle rest parameters. The position of the rest
      // parameter matters, so this requires some thought. The
      // following signatures are all different:
      // * function (...rest, foo, bar)
      // * function (foo, ...rest, bar)
      // * function (foo, bar, ...rest)
      // For now, just ignore rest parameters...
      if (key.indexOf('...') === 0) {
        continue
      }

      // If there is a default value defined, remove it from the
      // key.
      key = key.replace(/\s*=.*$/, '')

      // TODO: Should we do something with destructuring
      // assignments?

      signature.push(key)
    }

    return signature
  }
  else {
    return []
  }
}
420583
function() {
      var pairs = _self.querystring().split('&');
      var params = {};

      for(var i=0; i<pairs.length; i++) {
        if(pairs[i] === '') continue;
        var nameValue = pairs[i].split('=');
        params[nameValue[0]] = (typeof nameValue[1] === 'undefined' || nameValue[1] === '') ? true : decodeURIComponent(nameValue[1]);
      }

      return params;
    }
467549
function readName(buffer) {
  // Read name
  var nameLength = buffer.readUint32();
  var name = buffer.readChars(nameLength);

  // validate name
  // TODO

  // Apply padding
  padding(buffer);
  return name;
}