lodash: changed _.xor() method

lodash/lodash-tests.ts

@@ -354,10 +354,22 @@ result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).unique('x').v
 
 result = <number[]>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 
-result = <number[]>_.xor([1, 2, 3, 4, 5], [5, 2, 10]);
-result = <number[]>_.xor([1, 2, 3, 4, 5], [5, 2, 10], [4, 5, 6]);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).xor([5, 2, 10]);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).xor([5, 2, 10], [4, 5, 6]);
+// _.xor
+var testXorArray: number[];
+var testXorList: _.List<number>;
+result = <number[]>_.xor<number>();
+result = <number[]>_.xor<number>(testXorArray);
+result = <number[]>_.xor<number>(testXorArray, testXorArray);
+result = <number[]>_.xor<number>(testXorArray, testXorArray, testXorArray);
+result = <number[]>_.xor<number>(testXorList);
+result = <number[]>_.xor<number>(testXorList, testXorList);
+result = <number[]>_.xor<number>(testXorList, testXorList, testXorList);
+result = <number[]>(_(testXorArray).xor().value());
+result = <number[]>(_(testXorArray).xor(testXorArray).value());
+result = <number[]>(_(testXorArray).xor(testXorArray, testXorArray).value());
+result = <number[]>(_(testXorList).xor().value());
+result = <number[]>(_(testXorList).xor(testXorList).value());
+result = <number[]>(_(testXorList).xor(testXorList, testXorList).value());
 
 result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
 result = <any[][]>_.unzip(['moe', 'larry'], [30, 40], [true, false]);

lodash/lodash.d.ts

@@ -1868,33 +1868,25 @@ declare module _ {
     //_.xor
     interface LoDashStatic {
         /**
-        * Creates an array that is the symmetric difference of the provided arrays.
-        * @param array The array to process
-        * @param others The arrays of values to calculate the symmetric difference.
-        * @return Returns a new array of filtered values.
-        **/
-        xor<T>(
-            array: Array<T>,
-            ...others: Array<T>[]): T[];
-        /**
-        * @see _.xor
-        **/
-        xor<T>(
-            array: List<T>,
-            ...others: List<T>[]): T[];
+         * Creates an array of unique values that is the symmetric difference of the provided arrays.
+         * @param arrays The arrays to inspect.
+         * @return Returns the new array of values.
+         */
+        xor<T>(...arrays: List<T>[]): T[];
     }
 
     interface LoDashArrayWrapper<T> {
         /**
-        * @see _.xor
-        **/
-        xor(
-            ...others: Array<T>[]): LoDashArrayWrapper<T>;
+         * @see _.xor
+         */
+        xor(...arrays: T[][]): LoDashArrayWrapper<T>;
+    }
+
+    interface LoDashObjectWrapper<T> {
         /**
-        * @see _.xor
-        **/
-        xor(
-            ...others: List<T>[]): LoDashArrayWrapper<T>;
+         * @see _.xor
+         */
+        xor(...arrays: T[]): LoDashObjectWrapper<T>;
     }
 
     //_.zip