hack: have to override
 Array of array args with optional defaults. Scraped with MethodInspector
170406
def args(lib=library)
      @args = !@args.nil? ? @args : begin
        if lib
          file_string, meth = file_string_and_method_for_args(lib)
          (file_string && meth && (@file_parsed_args = true) &&
            MethodInspector.scrape_arguments(file_string, meth))
        end || false
      end
    end
374584
function(array, ind) {
    if (ind >= array.length || ind < 0) 
      throw new Error('$' + (ind + 1) + ': argument number out of range')
    return array[ind]
  }
69519
function (obj, method, args) {
        switch (args.length) {
        case 0: return obj[method]();
        case 1: return obj[method](args[0]);
        case 2: return obj[method](args[0], args[1]);
        case 3: return obj[method](args[0], args[1], args[2]);
        case 4: return obj[method](args[0], args[1], args[2], args[3]);
        case 5: return obj[method](args[0], args[1], args[2], args[3], args[4]);
        }
    }
310731
function patch(obj, method, optionsArgIndex) {
    var orig = obj[method];
    if (!orig) return;
    obj[method] = function () {
      var opts = arguments[optionsArgIndex];
      var file = null;
      if (opts) {
        file = typeof opts == 'string' ? opts : opts.filename;
      }
      if (file) callback(file);
      return orig.apply(this, arguments);
    };
  }
964061
def method_missing(method, *args)
			cls = $1 if method =~ /(.*)_picker/
			return super unless cls #not a valid picker method call
			args = (args + Array.new(3)).slice(0..2).push("#{cls}picker") #pad args to 3 and add cls attr to end
			send(:hd_picker, *args)
		end
407112
def find_method_add_from_raw(ripped_code, array = [])
      return false unless ripped_code.is_a?(Array)

      case ripped_code.first
      when :method_add_arg
        array << MethodAdd.new(ripped_code)
        ripped_code.shift
      when :command_call
        array << CommandCall.new(ripped_code)
        ripped_code.shift
      when :binary
        array << BinaryCall.new(ripped_code)
        ripped_code.shift
      end
      ripped_code.each do |code|
        find_method_add_from_raw(code, array) unless ripped_code.empty?
      end
    end
356898
function(options) {
		var length = this.promises.length,
			last = this.promises[length - 1];
		if (length && last) {
			last.rqMethod = function(scraper, url) {
				options.uri = url;
				scraper.request(options);
			};
			return this;
		} else {
			throw new ScraperError('');
		}
	}
657584
function onErrorResumeNext() {
    var nextSources = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        nextSources[_i] = arguments[_i];
    }
    if (nextSources.length === 1 && Object(_util_isArray__WEBPACK_IMPORTED_MODULE_2__["isArray"])(nextSources[0])) {
        nextSources = nextSources[0];
    }
    return function (source) { return source.lift(new OnErrorResumeNextOperator(nextSources)); };
}
1054665
function(inMethod, inArgs) {
		//var a$ = enyo.logging.formatArgs(inMethod, inArgs);
		var a$ = enyo.isArray(inArgs) ? inArgs : enyo.cloneArray(inArgs);
		if (enyo.dumbConsole) {
			// at least in early versions of webos, console.* only accept a single argument
			a$ = [a$.join(" ")];
		}
		var fn = console[inMethod];
		if (fn && fn.apply) {
			// some consoles support 'warn', 'info', and so on
			fn.apply(console, a$);
		} else if (console.log.apply) {
			// some consoles support console.log.apply
			console.log.apply(console, a$);
		} else {
			// otherwise, do our own formatting
			console.log(a$.join(" "));
		}
	}
911595
function(args, defaults) {
        var args = args || {};

        if (typeof defaults == 'object') {
          for (var key in defaults) {
            if (elation.utils.isNull(args[key])) {
              args[key] = defaults[key];
            }
          }
        }
        
        return args;
      }
514808
function() {
		var length = this.promises.length,
			last = this.promises[length - 1];
		if (length && last && !last.scraper) {
			var ss = StaticScraper.create();
			last.scraper = ss;
			return ss;
		} else {
			throw new ScraperError('');
		}
	}
1326147
function unwrapArray(arg, defaultValue) {
  const _arg = Array.isArray(arg)
    ? /* istanbul ignore next (preact) */ arg[0]
    : arg
  if (!_arg && defaultValue) {
    return defaultValue
  } else {
    return _arg
  }
}
90267
def _preprocess_override(meth_types, base_types, meth_argspec, base_argspec):
    
    try:
        base_kw = base_argspec.keywords
        kw = meth_argspec.keywords
    except AttributeError:
        base_kw = base_argspec.varkw
        kw = meth_argspec.varkw
    try:
        kwonly = meth_argspec.kwonlyargs
        base_kwonly = base_argspec.kwonlyargs
    except AttributeError:
        kwonly = None
        base_kwonly = None
    if meth_argspec.varargs is None and base_argspec.varargs is None \
            and kw is None and base_kw is None \
            and kwonly is None and base_kwonly is None \
            and (meth_argspec.defaults is None or \
                len(meth_argspec.args) == len(base_argspec.args)):
        return meth_types, base_types
    arg_types = type_util.get_Tuple_params(meth_types[0])
    base_arg_types = type_util.get_Tuple_params(base_types[0])
    kw_off = len(meth_argspec.args)-1 # -1 for self
    if not meth_argspec.defaults is None and base_argspec.varargs is None:
        kw_off -= len(meth_argspec.defaults)
    base_kw_off = len(base_argspec.args)
    if base_argspec.varargs is None:
        base_kw_off -= 1 # one decrement anyway for self
    arg_types2 = list(arg_types[:kw_off])
    base_arg_types2 = list(base_arg_types[:base_kw_off])
    base_vargtype = None
    vargtype = None
    base_argnames = None
    argnames = None
    if not base_argspec.varargs is None or not base_kw is None:
        base_argnames = util.getargnames(base_argspec)[1:]
        if not base_argspec.varargs is None:
            base_vargtype = base_arg_types[base_argnames.index(base_argspec.varargs)]
            # Should have been already checked:
            assert not meth_argspec.varargs is None
    if not meth_argspec.varargs is None or not kw is None:
        argnames = util.getargnames(meth_argspec)[1:]
        if not meth_argspec.varargs is None:
            vargtype = arg_types[argnames.index(meth_argspec.varargs)]
    if not meth_argspec.defaults is None:
        pos = 0
        if not base_argspec.varargs is None:
            # fill up parent's types with varg type to account for child's defaults
            while len(arg_types2) > len(base_arg_types2):
                base_arg_types2.append(base_vargtype)
            base_arg_types2.append(base_vargtype) # restore one more for the actual vargtype
        else:
            # parent has no vargtype, so fill up child with default-types afap
            while len(arg_types2) < len(base_arg_types2) and \
                    pos < len(meth_argspec.defaults):
                arg_types2.append(arg_types[kw_off+pos])
                pos += 1
    while len(arg_types2) < len(base_arg_types2):
        arg_types2.append(vargtype)
    if not kw is None:
        kw_type = arg_types[argnames.index(kw)]
    if not base_kwonly is None:
        for name in base_kwonly:
            base_arg_types2.append(base_arg_types[base_argnames.index(name)])
            if name in argnames:
                arg_types2.append(arg_types[argnames.index(name)])
            else:
                arg_types2.append(kw_type)
    if not base_kw is None:
        base_arg_types2.append(base_arg_types[base_argnames.index(base_kw)])
        arg_types2.append(kw_type)
    return (typing.Tuple[tuple(arg_types2)], meth_types[1]), \
            (typing.Tuple[tuple(base_arg_types2)], base_types[1])
123325
def method_missing(name, *args, &blk)
      if name.to_s =~ /^default_(.*)=$/
        @default_options[$1.to_sym] = args.first
      elsif name.to_s =~ /=$/
        @dirty_options[$`.to_sym] = args.first
      elsif @default_options.key?(name)
        dirty_or_db_setting_or_default(name)
      else
        super
      end
    end
1151232
function lintCSS (args = []) {
  if (!Array.isArray(args)) {
    throw new TypeError('arguments has to be an array')
  }

  const command = [
    `node ${resolveBin('stylelint')}`,
    '"src/**/*.?(s)css"',
    '--syntax scss',
    `--custom-formatter ${require.resolve('stylelint-codeframe-formatter')}`,
    ...args
  ].join(' ')

  console.log(chalk`\nCommand:\n{green ${command}}\n`)

  try {
    execSync(command, { stdio: 'inherit' })
  } catch (error) {
    return false
  }

  return true
}
78399
function wrapMutatingArrayMethod(method, func) {
      return function() {
        var result = [][method].apply(obj, arguments);
        this.len = this.values.length;
        cache = {};
        children = {};
        func.apply(this, arguments);
        target.parent.trigger('update', target.prop);
        return result;
      };
    }
1328160
def get_kwargs_defaults(argspec):
    """"""
    arg_names = tuple(argspec.args)
    defaults = argspec.defaults or ()
    num_args = len(argspec.args) - len(defaults)
    kwargs_defaults = {}
    for i, default_value in enumerate(defaults):
        kwargs_defaults[arg_names[num_args + i]] = default_value
    if getattr(argspec, "kwonlydefaults", None):
        kwargs_defaults.update(argspec.kwonlydefaults)
    return kwargs_defaults