Makes 'to' the set union of 'from' and 'to'.
@param {!{from: !Object.<string, boolean>, to: !Object.<string, boolean>}}
args
352298
function addSetValues(args) {
  for (var key in args.from) {
    if (args.from[key]) {
      args.to[key] = true;
    }
  }
}
1216545
function(array, from, to) {
			var rest = array.slice((to || from) + 1 || array.length);
			array.length = from < 0 ? array.length + from : from;
			return array.push.apply(array, rest);
		}
267157
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable A from, @Nullable A to) {
        if (from == null) {
            if (to != null) {
                return loe(to);
            } else {
                throw new IllegalArgumentException("Either from or to needs to be non-null");
            }
        } else if (to == null) {
            return goe(from);
        } else {
            return between(ConstantImpl.create(cast(from)), ConstantImpl.create(cast(to)));
        }
    }
210407
function convert(matrix, fromMap, fromUnit, toMap, toUnit) {
  const conv = matrix[toUnit][fromUnit],
    raw = fromMap[fromUnit] / conv,
    sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]),
    // ok, so this is wild, but see the matrix in the tests
    added =
      !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw);
  toMap[toUnit] += added;
  fromMap[fromUnit] -= added * conv;
}
1040659
function(str, to) {
    if (isUndefined(to)) to = str.length;
    return str.slice(0, numberOrIndex(str, to));
  }
1289041
function union(callbacks, wrap) {
    if (arguments.length === 1 || arguments.length === 2 && typeof wrap === 'boolean') {
      if (!Array.isArray(callbacks)) {
        callbacks = [callbacks];
      }
      for (var i = 0, l = callbacks.length; i < l; i++) {
        this._statements.push({
          grouping: 'union',
          clause: 'union',
          value: callbacks[i],
          wrap: wrap || false
        });
      }
    } else {
      callbacks = normalizeArr.apply(null, arguments).slice(0, arguments.length - 1);
      wrap = arguments[arguments.length - 1];
      if (typeof wrap !== 'boolean') {
        callbacks.push(wrap);
        wrap = false;
      }
      this.union(callbacks, wrap);
    }
    return this;
  }
779143
function (args) {
    var i, val, akey, result = {};
    Object.keys(args).forEach(function (key) {
        val = args[key];
        if (Array.isArray(val)) {
            for (i = 0; i < val.length; i++) {
                akey = key + '[' + i + ']';
                result[akey] = val[i];
            }
        }
        else {
            result[key] = val;
        }
    });
    return result;
}
310715
function(into, from) {
  for (var key in from) {
    if (into[key] instanceof Object &&
        !(into[key] instanceof Array) &&
        !(into[key] instanceof Function)) {
      merge_(into[key], from[key]);
    } else {
      into[key] = from[key];
    }
  }
  return into;
}
1230767
function sub(seq, from, to) {
  var f = Array.isArray(seq) ? seq.slice : seq.substring
  return to == null ? f.call(seq, from) : f.call(seq, from, to)
}
83338
public static <T> String argsToString(String separator, T... args) {
    StringBuilder sb = new StringBuilder();
    for (T s : args) {
      if (sb.length() != 0) {
        sb.append(separator);
      }
      sb.append(s);
    }
    return sb.toString();
  }
1349242
function argsToObject(args) {
  var options = {};
  options.address = args.shift();
  options.output = args.shift();

  // Pair two arguments, while transforming the key to camelCase
  for (i = 0; i < args.length; i = i + 2) {
    options[toCamelCase(args[i].substr(2))] = args[i + 1];
  }

  return options;
}
1204350
@SuppressWarnings(
	{ "unchecked" })
	public static <T> Set<T> toSet(T...args)
	{
		if(args == null || args.length ==0)
			return null;
		
		HashSet<T> set = new HashSet<>(args.length);
		
		fill(set,args);
		return set;
	}
190407
function froms(froms) {
  var args = Array.prototype.splice.call(arguments, 0);
  if (isUndefined(froms)) {
    froms = [];
  }

  if (!isArray(froms)) {
    throw {
      name: 'Error',
      message: 'Argument is not an array',
      arguments: args
    };
  }

  var f = froms
    .filter(function (from) {
      return !isUndefined(from);
    })
    .map(function (from) {
      if (isObject(from)) {
        if (isUndefined(from.target) && isUndefined(from.default)) {
          throw {
            name: 'Error',
            message: 'from.target and from.default are both undefined',
            arguments: args
          };
        }
        if (isUndefined(from.default) && !isString(from.target)) {
          throw {
            name: 'Error',
            message: 'from.target is not a string',
            arguments: args
          };
        }
        return from;
      } else {
        return {
          target: from
        };
      };
    });

  return f;
}
630290
function range(from, to) {
  // TODO: make this inlined.
  const list = new Array(to - from + 1);

  for (let i = 0; i < list.length; i += 1) {
    list[i] = from + i;
  }
  return list;
}
28902
function from(arg){
		if(!_.isArray(arg) && !_.isArguments(arg))
			arg = [arg];
		
		return _.toArray(arg);
	}
409223
function to(obj, func, map) {
    if(!obj || typeof obj !== "object") return obj;

    if(obj instanceof Date) return obj;

    if(Array.isArray(obj)) {
        var res = [];
        for(var i = 0; i < obj.length; i++) {
            res.push(to(obj[i], func, map));
        }
        return res;
    }

    var res = {};
    for(var key in obj) {
        if(!obj.hasOwnProperty(key)) continue;

        /**
         * Rules:
         *
         * 1. $...: keep origin;
         * 2. otherwise;
         *   2.1. map[key] exists: map[key];
         *   2.2. otherwise: func(key).
         */
        const newKey = (key[0] === "$" ? key : (map[key] || func(key)))
        res[newKey] = to(obj[key], func, map);
    }
    return res;
}
271506
function mergeData (to, from) {
	  var key, toVal, fromVal;
	  for (key in from) {
	    toVal = to[key];
	    fromVal = from[key];
	    if (!hasOwn(to, key)) {
	      set(to, key, fromVal);
	    } else if (isObject(toVal) && isObject(fromVal)) {
	      mergeData(toVal, fromVal);
	    }
	  }
	  return to
	}