The seal function seals all supplied arguments.
498752
public static void seal(Context cx, Scriptable thisObj, Object[] args,
                            Function funObj)
    {
        for (int i = 0; i != args.length; ++i) {
            Object arg = args[i];
            if (!(arg instanceof ScriptableObject) || arg == Undefined.instance)
            {
                if (!(arg instanceof Scriptable) || arg == Undefined.instance)
                {
                    throw reportRuntimeError("msg.shell.seal.not.object");
                } else {
                    throw reportRuntimeError("msg.shell.seal.not.scriptable");
                }
            }
        }

        for (int i = 0; i != args.length; ++i) {
            Object arg = args[i];
            ((ScriptableObject)arg).sealObject();
        }
    }
866253
def with_args(self, *args, **kwargs):
        

        self.args = args
        self.kwargs = kwargs
        self.verify_arguments()
        return self
618414
private void ssApplyAllCaseFold(int flag, ApplyAllCaseFoldFunction fun, Object arg) {
        fun.apply(0xdf, SS, 2, arg);
    }
510215
def _simplify_arguments(arguments):
    
    if len(arguments.args) == 0:
        return arguments.kwargs
    elif len(arguments.kwargs) == 0:
        return arguments.args
    else:
        return arguments
630763
def arguments(self, args):
        """"""
        self.args = args
        self.manage_flags()
        self.filename = self.args[0]
        if len(self.args) == 1 and self.args[0] in self.options[:2]:
            print(self.help.__doc__)
        elif len(self.args) == 1 and self.args[0] in self.options[2:4]:
            self.version()
        elif len(self.args) == 2 and self.args[0] in self.options[4:5]:
            self.filename = self.args[1]
            self.remove()
        elif len(self.args) == 2 and self.args[0] in self.options[6:7]:
            self.filename = self.args[1]
            self.remove()
        elif len(self.args) == 1:
            if os.path.isfile(self.args[0]):
                self.remove()
            else:
                self.not_access()
        else:
            self.usage()
126387
function wrapArgs(fns) {
  const ret = [];
  for (const fn of fns) {
    if (typeof fn !== 'function') {
      ret.push(fn);
      continue;
    }
    ret.push(wrap(fn));
  }
  return ret;
}
862063
function(operation, key, args, callback) {
		var operationArgs = [key].concat(args)
		if (callback) { operationArgs.push(callback) }
		storeAPI[operation].apply(this, operationArgs)
	}
1326249
def all(self, msg, *args, **kwargs):
        
        self.multi(ALL, msg, args, **kwargs)
526781
function (/* arguments */) { var args = arguments
        log.withWriteBackend (
            log.impl.defaultWriteBackend,
            function (done) {
                log.write.apply (null, args); done () }) }
1174982
private void initCompilerClosureArgumentsFromConfig(List<String> args, JawrConfig config) {
		Set<Entry<Object, Object>> entrySet = config.getConfigProperties().entrySet();
		for (Entry<Object, Object> propEntry : entrySet) {
			String key = (String) propEntry.getKey();
			if (key.startsWith(JAWR_JS_CLOSURE_PREFIX) && !JAWR_JS_CLOSURE_SPECIFIC_PROPERTIES.contains(key)) {

				String compilerArgName = key.substring(JAWR_JS_CLOSURE_PREFIX.length());
				checkCompilerArgumentName(compilerArgName);
				String compilerArgValue = (String) propEntry.getValue();
				compilerArgValue = getCompilerArgValue(compilerArgName, compilerArgValue);
				args.add(CLOSURE_ARGUMENT_NAME_PREFIX + compilerArgName);
				args.add(propEntry.getValue().toString());
			}
		}

		// Add default compilation level argument
		if (!args.contains(COMPILATION_LEVEL_ARG)) {
			args.add(COMPILATION_LEVEL_ARG);
			args.add(WHITESPACE_ONLY_COMPILATION_LEVEL);
		}

		// Add default level warning argument if not defined
		if (!args.contains(WARNING_LEVEL_ARG)) {
			args.add(WARNING_LEVEL_ARG);
			args.add(VERBOSE_WARNING_LEVEL);
		}
	}
692448
def pack_args(self, obj, *args, **kwargs):
        
        signature = self.__signature__
        #: No arguments expected
        if not signature:
            return (self.name, [])

        #: Build args, first is a string, subsequent are dictionaries
        method_name = [self.name]
        bridge_args = []
        for i, sig in enumerate(signature):
            if i == 0:
                method_name.append(":")
                bridge_args.append(msgpack_encoder(sig, args[0]))
                continue

            #: Sig is a dict so we must pull out the matching kwarg
            found = False
            for k in sig:
                if k in kwargs:
                    method_name.append("{}:".format(k))
                    bridge_args.append(msgpack_encoder(sig[k], kwargs[k]))
                    found = True
                    break
            if not found:
                #: If we get here something is wrong
                raise ValueError("Unexpected or missing argument at index {}. "
                                 "Expected {}".format(i, sig))

        return ("".join(method_name), bridge_args)
1068931
function getArguments( fn ) {
	return _.isFunction( fn ) ? trim( /[(]([^)]*)[)]/.exec( fn.toString() )[ 1 ].split( ',' ) ) : [];
}
133267
function wrap(fn) {
  return function () {
    var self = this, args = arguments;
    this.domain.run(function () {
      fn.apply(self, args);
    });
  };
}
1371239
private void sealObject(ScriptableObject obj) {
		obj.sealObject();
		Object[] ids = obj.getIds();
		for (Object id : ids) {
			Object child = obj.get(id);
			if (child instanceof ScriptableObject) {
				sealObject((ScriptableObject)child);
			}
		}
	}
910317
def _CollectArguments(function, args, kwargs):
  """"""
  all_args = dict(kwargs)
  arg_names = inspect.getargspec(function)[0]
  for position, arg in enumerate(args):
    if position < len(arg_names):
      all_args[arg_names[position]] = arg
  return all_args
1011284
def handler_all(func=None):
	
	if not func:
		return functools.partial(handler_all)

	registrations_global.append(func)

	return func
651342
def wrap_connection(func_, *args, **kwargs):
    
    if not args[-1]:
        new_args = list(args)
        new_args[-1] = connect()
        args = tuple(new_args)
    return func_(*args, **kwargs)