Parse arguments to array

@param {Arguments} a
@param {Number|null} start
@param {Number|null} end
@returns {Array}
963531
function _A(a) {
        return Array.prototype.slice.apply(a, Array.prototype.slice.call(arguments, 1));
    }
504184
function DumperGetArgs(a,index) {
	var args = new Array();
	// This is kind of ugly, but I don't want to use js1.2 functions, just in case...
	for (var i=index; i<a.length; i++) {
		args[args.length] = a[i];
	}
	return args;
}
1157654
function _parseParams(params, defaults) {
  const options = {};
  const attrs = {};

  Utils.each(params, (value, key) => {
    const coerced = Utils.coerceType(value);

    if (Utils.has(defaults.options, key)) {
      options[key] = coerced;
    } else if (Utils.has(defaults.attrs, key)) {
      attrs[key] = coerced;
    }
  });

  return [options, attrs];
}
475175
function (start, end) {
      var r, rlen, c, clen, output = [], row;
      rlen = Math.max(start.row, end.row);
      clen = Math.max(start.col, end.col);
      for (r = Math.min(start.row, end.row); r <= rlen; r++) {
        row = [];
        for (c = Math.min(start.col, end.col); c <= clen; c++) {
          row.push(datamap.get(r, datamap.colToProp(c)));
        }
        output.push(row);
      }
      return output;
    }
790587
public static function extract_arguments($text, $begin = null, $end = null)
	{
		$argv = [];
		if(!empty($text))
		{
			$args = explode(',', $text);
			foreach ($args as $a) {
				// trim the argument
				$a = trim( $this->trim_string($a) );
				// parse null
				if(strtolower($a) == "null")
					$a = null;
				array_push($argv, $a);
			}
		}
		return $argv;
	}
188240
function get(start, end) {
			var result = [],
				i;

			for (i = Math.max(0, start); i < end && i < length; i++) {
				result.push(tokens[i]);
			}

			return result;
		}
360104
function(args){
			var arr = [];
			each(args, function(i, str){arr[i] = str});
			return arr;
		}
891949
function map(array, expression) {

  if(!isArray(array) || isUndefined(expression)) {
    return array;
  }

  return array.map(function (elm) {
    return $parse(expression)(elm);
  });
}
327407
function(a){
            if(!a || !this.isArray(a)) return; 

            var i = 0,start = 0,len = a.length;

            for(;i < len; i++){
             if(!this.isUndefined(a[i]) && !this.isNull(a[i]) && !(this.isEmpty(a[i]))){
              a[start]=a[i];
              start += 1;
            }
          }

          a.length = start;
          return a;
    }
217858
function parseArgs (argv, args) {
  var argc = argv.length;
  var sel;
  if (argc === 1) {
    var arg = argv[0];
    if (typeof arg === 'string') {
      // selector with no arguments
      sel = arg;
    } else {
      // legacy API: an Object was passed in
      sel = [];
      Object.keys(arg).forEach(function (s) {
        sel.push(s);
        args.push(arg[s]);
      });
      sel.push('');
      sel = sel.join(':');
    }
  } else {
    // varargs API
    sel = [];
    for (var i=0; i<argc; i+=2) {
      sel.push(argv[i]);
      args.push(argv[i+1]);
    }
    sel.push('');
    sel = sel.join(':');
  }
  return sel;
}
782529
function parse(argv) {
  if (Array.isArray(argv)) {
    argv = argv.join(" ");
  }

  var opts = {};
  var paramStr = argv.replace(/(-{1,2}\S+?)\s+((?!-)[\S]+)/g, function(pair){
    var match = pair.match(/-{1,2}(\S+?)\s+((?!-)[\S]+)/);
    var key = match[1], value = match[2];
    try {
      value = JSON.parse(value);
    } catch (error) {}

    val(opts, key, value);
    return '';
  });

  var flags = {};
  var params = paramStr.split(' ').filter(function(param) {
    if (param == '') return false;
    if (param.search(/^-/) == 0) {
      param = param.replace(/^-{1,2}/, '');
      val(flags, param, true);
      return false;
    }
    return true;

  }).map(function(str) {
    try {
      return JSON.parse(str);
    } catch(error) {
      return str;
    }
  });

  return { opts: opts, params: params, flags: flags };
}
775726
function parseArguments$3(args) {
        var first = args[0];
        var second = args[1];

        return typeof first === 'string' ? { namespace: first, mappings: second } : { namespace: null, mappings: first };
    }
80784
function _arraySlice(start, end, arr) {
    var len = arr.length;
    var range = [];
    start = idx(len, start);
    end = idx(len, end, len);
    while (start < end) {
        range.push(arr[start++]);
    }
    return range;
    function idx(len, pos, end) {
        if (end === void 0) { end = undefined; }
        if (pos == null) {
            pos = end || 0;
        }
        else if (pos < 0) {
            pos = Math.max(len + pos, 0);
        }
        else {
            pos = Math.min(pos, len);
        }
        return pos;
    }
}
59863
function getArgs (fn) {
  const fnString = fn.toString();
  const argList = /[(]([^)]*)[)]/.exec(fnString)[ 1 ].split(',');
  return argList.map(String.prototype.trim);
}
122243
function ( obj, start, offset ) {
		var result = [],
		    i      = start - 1,
		    nth    = start + offset,
		    max    = obj.length;

		if ( max > 0 ) {
			while ( ++i < nth && i < max ) {
				result.push( obj[i] );
			}
		}

		return result;
	}
989664
function toArray (a, start) {
    var dest = [], i = start || 0, len = a.length;
    for (; i < len; i++) dest.push(a[i]);
    return dest;
  }
193753
function(arr, num) {
    if (isUndefined(num)) return arr[arr.length - 1];
    var start = arr.length - num < 0 ? 0 : arr.length - num;
    return arr.slice(start);
  }