/ - Diff - Webová aplikace simulující kontingenční tabulku (CIV) - VLDC - Redmine

     // optional / simple context binding
     var aFunction = require('./_a-function');
     module.exports = function (fn, that, length) {
       aFunction(fn);
       if (that === undefined) return fn;
       switch (length) {
         case 1: return function (a) {
           return fn.call(that, a);
         };
         case 2: return function (a, b) {
           return fn.call(that, a, b);
         };
         case 3: return function (a, b, c) {
           return fn.call(that, a, b, c);
         };
+      }
       return function (/* ...args */) {
         return fn.apply(that, arguments);
       };
     };

     // optional / simple context binding
     var aFunction = require('./_a-function');
     module.exports = function (fn, that, length) {
       aFunction(fn);
       if (that === undefined) return fn;
       switch (length) {
         case 1: return function (a) {
           return fn.call(that, a);
         };
         case 2: return function (a, b) {
           return fn.call(that, a, b);
         };
         case 3: return function (a, b, c) {
           return fn.call(that, a, b, c);
         };
+      }
       return function (/* ...args */) {
         return fn.apply(that, arguments);
       };
     };

     var apply = require('./_apply'),
         createCtor = require('./_createCtor'),
         createHybrid = require('./_createHybrid'),
         createRecurry = require('./_createRecurry'),
         getHolder = require('./_getHolder'),
         replaceHolders = require('./_replaceHolders'),
         root = require('./_root');
     /**
      * Creates a function that wraps `func` to enable currying.
+     *
      * @private
      * @param {Function} func The function to wrap.
      * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
      * @param {number} arity The arity of `func`.
      * @returns {Function} Returns the new wrapped function.
      */
     function createCurry(func, bitmask, arity) {
       var Ctor = createCtor(func);
       function wrapper() {
         var length = arguments.length,
             args = Array(length),
             index = length,
             placeholder = getHolder(wrapper);
         while (index--) {
           args[index] = arguments[index];
+        }
         var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
           ? []
           : replaceHolders(args, placeholder);
         length -= holders.length;
         if (length < arity) {
           return createRecurry(
             func, bitmask, createHybrid, wrapper.placeholder, undefined,
             args, holders, undefined, undefined, arity - length);
+        }
         var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
         return apply(fn, this, args);
+      }
       return wrapper;
+    }
     module.exports = createCurry;

     var baseIteratee = require('./_baseIteratee'),
         isArrayLike = require('./isArrayLike'),
         keys = require('./keys');
     /**
      * Creates a `_.find` or `_.findLast` function.
+     *
      * @private
      * @param {Function} findIndexFunc The function to find the collection index.
      * @returns {Function} Returns the new find function.
      */
     function createFind(findIndexFunc) {
       return function(collection, predicate, fromIndex) {
         var iterable = Object(collection);
         if (!isArrayLike(collection)) {
           var iteratee = baseIteratee(predicate, 3);
           collection = keys(collection);
           predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+        }
         var index = findIndexFunc(collection, predicate, fromIndex);
         return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
       };
+    }
     module.exports = createFind;

     var LodashWrapper = require('./_LodashWrapper'),
         flatRest = require('./_flatRest'),
         getData = require('./_getData'),
         getFuncName = require('./_getFuncName'),
         isArray = require('./isArray'),
         isLaziable = require('./_isLaziable');
     /** Error message constants. */
     var FUNC_ERROR_TEXT = 'Expected a function';
     /** Used to compose bitmasks for function metadata. */
     var WRAP_CURRY_FLAG = 8,
         WRAP_PARTIAL_FLAG = 32,
         WRAP_ARY_FLAG = 128,
         WRAP_REARG_FLAG = 256;
     /**
      * Creates a `_.flow` or `_.flowRight` function.
+     *
      * @private
      * @param {boolean} [fromRight] Specify iterating from right to left.
      * @returns {Function} Returns the new flow function.
      */
     function createFlow(fromRight) {
       return flatRest(function(funcs) {
         var length = funcs.length,
             index = length,
             prereq = LodashWrapper.prototype.thru;
         if (fromRight) {
           funcs.reverse();
+        }
         while (index--) {
           var func = funcs[index];
           if (typeof func != 'function') {
             throw new TypeError(FUNC_ERROR_TEXT);
+          }
           if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
             var wrapper = new LodashWrapper([], true);
+          }
+        }
         index = wrapper ? index : length;
         while (++index < length) {
           func = funcs[index];
           var funcName = getFuncName(func),
               data = funcName == 'wrapper' ? getData(func) : undefined;
           if (data && isLaziable(data[0]) &&
                 data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
                 !data[4].length && data[9] == 1
               ) {
             wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
           } else {
             wrapper = (func.length == 1 && isLaziable(func))
               ? wrapper[funcName]()
               : wrapper.thru(func);
+          }
+        }
         return function() {
           var args = arguments,
               value = args[0];
           if (wrapper && args.length == 1 && isArray(value)) {
             return wrapper.plant(value).value();
+          }
           var index = 0,
               result = length ? funcs[index].apply(this, args) : value;
           while (++index < length) {
             result = funcs[index].call(this, result);
+          }
           return result;
         };
       });
+    }
     module.exports = createFlow;

     var composeArgs = require('./_composeArgs'),
         composeArgsRight = require('./_composeArgsRight'),
         countHolders = require('./_countHolders'),
         createCtor = require('./_createCtor'),
         createRecurry = require('./_createRecurry'),
         getHolder = require('./_getHolder'),
         reorder = require('./_reorder'),
         replaceHolders = require('./_replaceHolders'),
         root = require('./_root');
     /** Used to compose bitmasks for function metadata. */
     var WRAP_BIND_FLAG = 1,
         WRAP_BIND_KEY_FLAG = 2,
         WRAP_CURRY_FLAG = 8,
         WRAP_CURRY_RIGHT_FLAG = 16,
         WRAP_ARY_FLAG = 128,
         WRAP_FLIP_FLAG = 512;
     /**
      * Creates a function that wraps `func` to invoke it with optional `this`
      * binding of `thisArg`, partial application, and currying.
+     *
      * @private
      * @param {Function|string} func The function or method name to wrap.
      * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
      * @param {*} [thisArg] The `this` binding of `func`.
      * @param {Array} [partials] The arguments to prepend to those provided to
      *  the new function.
      * @param {Array} [holders] The `partials` placeholder indexes.
      * @param {Array} [partialsRight] The arguments to append to those provided
      *  to the new function.
      * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
      * @param {Array} [argPos] The argument positions of the new function.
      * @param {number} [ary] The arity cap of `func`.
      * @param {number} [arity] The arity of `func`.
      * @returns {Function} Returns the new wrapped function.
      */
     function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
       var isAry = bitmask & WRAP_ARY_FLAG,
           isBind = bitmask & WRAP_BIND_FLAG,
           isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
           isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
           isFlip = bitmask & WRAP_FLIP_FLAG,
           Ctor = isBindKey ? undefined : createCtor(func);
       function wrapper() {
         var length = arguments.length,
             args = Array(length),
             index = length;
         while (index--) {
           args[index] = arguments[index];
+        }
         if (isCurried) {
           var placeholder = getHolder(wrapper),
               holdersCount = countHolders(args, placeholder);
+        }
         if (partials) {
           args = composeArgs(args, partials, holders, isCurried);
+        }
         if (partialsRight) {
           args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
+        }
         length -= holdersCount;
         if (isCurried && length < arity) {
           var newHolders = replaceHolders(args, placeholder);
           return createRecurry(
             func, bitmask, createHybrid, wrapper.placeholder, thisArg,
             args, newHolders, argPos, ary, arity - length
           );
+        }
         var thisBinding = isBind ? thisArg : this,
             fn = isBindKey ? thisBinding[func] : func;
         length = args.length;
         if (argPos) {
           args = reorder(args, argPos);
         } else if (isFlip && length > 1) {
           args.reverse();
+        }
         if (isAry && ary < length) {
           args.length = ary;
+        }
         if (this && this !== root && this instanceof wrapper) {
           fn = Ctor || createCtor(fn);
+        }
         return fn.apply(thisBinding, args);
+      }
       return wrapper;
+    }
     module.exports = createHybrid;

     var baseInverter = require('./_baseInverter');
     /**
      * Creates a function like `_.invertBy`.
+     *
      * @private
      * @param {Function} setter The function to set accumulator values.
      * @param {Function} toIteratee The function to resolve iteratees.
      * @returns {Function} Returns the new inverter function.
      */
     function createInverter(setter, toIteratee) {
       return function(object, iteratee) {
         return baseInverter(object, setter, toIteratee(iteratee), {});
       };
+    }
     module.exports = createInverter;

     var baseToNumber = require('./_baseToNumber'),
         baseToString = require('./_baseToString');
     /**
      * Creates a function that performs a mathematical operation on two values.
+     *
      * @private
      * @param {Function} operator The function to perform the operation.
      * @param {number} [defaultValue] The value used for `undefined` arguments.
      * @returns {Function} Returns the new mathematical operation function.
      */
     function createMathOperation(operator, defaultValue) {
       return function(value, other) {
         var result;
         if (value === undefined && other === undefined) {
           return defaultValue;
+        }
         if (value !== undefined) {
           result = value;
+        }
         if (other !== undefined) {
           if (result === undefined) {
             return other;
+          }
           if (typeof value == 'string' || typeof other == 'string') {
             value = baseToString(value);
             other = baseToString(other);
           } else {
             value = baseToNumber(value);
             other = baseToNumber(other);
+          }
           result = operator(value, other);
+        }
         return result;
       };
+    }
     module.exports = createMathOperation;

     var apply = require('./_apply'),
         arrayMap = require('./_arrayMap'),
         baseIteratee = require('./_baseIteratee'),
         baseRest = require('./_baseRest'),
         baseUnary = require('./_baseUnary'),
         flatRest = require('./_flatRest');
     /**
      * Creates a function like `_.over`.
+     *
      * @private
      * @param {Function} arrayFunc The function to iterate over iteratees.
      * @returns {Function} Returns the new over function.
      */
     function createOver(arrayFunc) {
       return flatRest(function(iteratees) {
         iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
         return baseRest(function(args) {
           var thisArg = this;
           return arrayFunc(iteratees, function(iteratee) {
             return apply(iteratee, thisArg, args);
           });
         });
       });
+    }
     module.exports = createOver;

     var baseRepeat = require('./_baseRepeat'),
         baseToString = require('./_baseToString'),
         castSlice = require('./_castSlice'),
         hasUnicode = require('./_hasUnicode'),
         stringSize = require('./_stringSize'),
         stringToArray = require('./_stringToArray');
     /* Built-in method references for those with the same name as other `lodash` methods. */
     var nativeCeil = Math.ceil;
     /**
      * Creates the padding for `string` based on `length`. The `chars` string
      * is truncated if the number of characters exceeds `length`.
+     *
      * @private
      * @param {number} length The padding length.
      * @param {string} [chars=' '] The string used as padding.
      * @returns {string} Returns the padding for `string`.
      */
     function createPadding(length, chars) {
       chars = chars === undefined ? ' ' : baseToString(chars);
       var charsLength = chars.length;
       if (charsLength < 2) {
         return charsLength ? baseRepeat(chars, length) : chars;
+      }
       var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
       return hasUnicode(chars)
         ? castSlice(stringToArray(result), 0, length).join('')
         : result.slice(0, length);
+    }
     module.exports = createPadding;

     var apply = require('./_apply'),
         createCtor = require('./_createCtor'),
         root = require('./_root');
     /** Used to compose bitmasks for function metadata. */
     var WRAP_BIND_FLAG = 1;
     /**
      * Creates a function that wraps `func` to invoke it with the `this` binding
      * of `thisArg` and `partials` prepended to the arguments it receives.
+     *
      * @private
      * @param {Function} func The function to wrap.
      * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
      * @param {*} thisArg The `this` binding of `func`.
      * @param {Array} partials The arguments to prepend to those provided to
      *  the new function.
      * @returns {Function} Returns the new wrapped function.
      */
     function createPartial(func, bitmask, thisArg, partials) {
       var isBind = bitmask & WRAP_BIND_FLAG,
           Ctor = createCtor(func);
       function wrapper() {
         var argsIndex = -1,
             argsLength = arguments.length,
             leftIndex = -1,
             leftLength = partials.length,
             args = Array(leftLength + argsLength),
             fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
         while (++leftIndex < leftLength) {
           args[leftIndex] = partials[leftIndex];
+        }
         while (argsLength--) {
           args[leftIndex++] = arguments[++argsIndex];
+        }
         return apply(fn, isBind ? thisArg : this, args);
+      }
       return wrapper;
+    }
     module.exports = createPartial;

     var baseRange = require('./_baseRange'),
         isIterateeCall = require('./_isIterateeCall'),
         toFinite = require('./toFinite');
     /**
      * Creates a `_.range` or `_.rangeRight` function.
+     *
      * @private
      * @param {boolean} [fromRight] Specify iterating from right to left.
      * @returns {Function} Returns the new range function.
      */
     function createRange(fromRight) {
       return function(start, end, step) {
         if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
           end = step = undefined;
+        }
         // Ensure the sign of `-0` is preserved.
         start = toFinite(start);
         if (end === undefined) {
           end = start;
           start = 0;
         } else {
           end = toFinite(end);
+        }
         step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
         return baseRange(start, end, step, fromRight);
       };
+    }
     module.exports = createRange;

     var isLaziable = require('./_isLaziable'),
         setData = require('./_setData'),
         setWrapToString = require('./_setWrapToString');
     /** Used to compose bitmasks for function metadata. */
     var WRAP_BIND_FLAG = 1,
         WRAP_BIND_KEY_FLAG = 2,
         WRAP_CURRY_BOUND_FLAG = 4,
         WRAP_CURRY_FLAG = 8,
         WRAP_PARTIAL_FLAG = 32,
         WRAP_PARTIAL_RIGHT_FLAG = 64;
     /**
      * Creates a function that wraps `func` to continue currying.
+     *
      * @private
      * @param {Function} func The function to wrap.
      * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
      * @param {Function} wrapFunc The function to create the `func` wrapper.
      * @param {*} placeholder The placeholder value.
      * @param {*} [thisArg] The `this` binding of `func`.
      * @param {Array} [partials] The arguments to prepend to those provided to
      *  the new function.
      * @param {Array} [holders] The `partials` placeholder indexes.
      * @param {Array} [argPos] The argument positions of the new function.
      * @param {number} [ary] The arity cap of `func`.
      * @param {number} [arity] The arity of `func`.
      * @returns {Function} Returns the new wrapped function.
      */
     function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
       var isCurry = bitmask & WRAP_CURRY_FLAG,
           newHolders = isCurry ? holders : undefined,
           newHoldersRight = isCurry ? undefined : holders,
           newPartials = isCurry ? partials : undefined,
           newPartialsRight = isCurry ? undefined : partials;
       bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
       bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
       if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
         bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
+      }
       var newData = [
         func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
         newHoldersRight, argPos, ary, arity
       ];
       var result = wrapFunc.apply(undefined, newData);
       if (isLaziable(func)) {
         setData(result, newData);
+      }
       result.placeholder = placeholder;
       return setWrapToString(result, func, bitmask);
+    }
     module.exports = createRecurry;

     var toNumber = require('./toNumber');
     /**
      * Creates a function that performs a relational operation on two values.
+     *
      * @private
      * @param {Function} operator The function to perform the operation.
      * @returns {Function} Returns the new relational operation function.
      */
     function createRelationalOperation(operator) {
       return function(value, other) {
         if (!(typeof value == 'string' && typeof other == 'string')) {
           value = toNumber(value);
           other = toNumber(other);
+        }
         return operator(value, other);
       };
+    }
     module.exports = createRelationalOperation;

     var root = require('./_root'),
         toInteger = require('./toInteger'),
         toNumber = require('./toNumber'),
         toString = require('./toString');
     /* Built-in method references for those with the same name as other `lodash` methods. */
     var nativeIsFinite = root.isFinite,
         nativeMin = Math.min;
     /**
      * Creates a function like `_.round`.
+     *
      * @private
      * @param {string} methodName The name of the `Math` method to use when rounding.
      * @returns {Function} Returns the new round function.
      */
     function createRound(methodName) {
       var func = Math[methodName];
       return function(number, precision) {
         number = toNumber(number);
         precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
         if (precision && nativeIsFinite(number)) {
           // Shift with exponential notation to avoid floating-point issues.
           // See [MDN](https://mdn.io/round#Examples) for more details.
           var pair = (toString(number) + 'e').split('e'),
               value = func(pair[0] + 'e' + (+pair[1] + precision));
           pair = (toString(value) + 'e').split('e');
           return +(pair[0] + 'e' + (+pair[1] - precision));
+        }
         return func(number);
       };
+    }
     module.exports = createRound;

     var Set = require('./_Set'),
         noop = require('./noop'),
         setToArray = require('./_setToArray');
     /** Used as references for various `Number` constants. */
     var INFINITY = 1 / 0;
     /**
      * Creates a set object of `values`.
+     *
      * @private
      * @param {Array} values The values to add to the set.
      * @returns {Object} Returns the new set.
      */
     var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
       return new Set(values);
     };
     module.exports = createSet;

     var baseToPairs = require('./_baseToPairs'),
         getTag = require('./_getTag'),
         mapToArray = require('./_mapToArray'),
         setToPairs = require('./_setToPairs');
     /** `Object#toString` result references. */
     var mapTag = '[object Map]',
         setTag = '[object Set]';
     /**
      * Creates a `_.toPairs` or `_.toPairsIn` function.
+     *
      * @private
      * @param {Function} keysFunc The function to get the keys of a given object.
      * @returns {Function} Returns the new pairs function.
      */
     function createToPairs(keysFunc) {
       return function(object) {
         var tag = getTag(object);
         if (tag == mapTag) {
           return mapToArray(object);
+        }
         if (tag == setTag) {
           return setToPairs(object);
+        }
         return baseToPairs(object, keysFunc(object));
       };
+    }
     module.exports = createToPairs;

     var baseSetData = require('./_baseSetData'),
         createBind = require('./_createBind'),
         createCurry = require('./_createCurry'),
         createHybrid = require('./_createHybrid'),
         createPartial = require('./_createPartial'),
         getData = require('./_getData'),
         mergeData = require('./_mergeData'),
         setData = require('./_setData'),
         setWrapToString = require('./_setWrapToString'),
         toInteger = require('./toInteger');
     /** Error message constants. */
     var FUNC_ERROR_TEXT = 'Expected a function';
     /** Used to compose bitmasks for function metadata. */
     var WRAP_BIND_FLAG = 1,
         WRAP_BIND_KEY_FLAG = 2,
         WRAP_CURRY_FLAG = 8,
         WRAP_CURRY_RIGHT_FLAG = 16,
         WRAP_PARTIAL_FLAG = 32,
         WRAP_PARTIAL_RIGHT_FLAG = 64;
     /* Built-in method references for those with the same name as other `lodash` methods. */
     var nativeMax = Math.max;
     /**
      * Creates a function that either curries or invokes `func` with optional
      * `this` binding and partially applied arguments.
+     *
      * @private
      * @param {Function|string} func The function or method name to wrap.
      * @param {number} bitmask The bitmask flags.
      *    1 - `_.bind`
      *    2 - `_.bindKey`
      *    4 - `_.curry` or `_.curryRight` of a bound function
      *    8 - `_.curry`
      *   16 - `_.curryRight`
      *   32 - `_.partial`
      *   64 - `_.partialRight`
      *  128 - `_.rearg`
      *  256 - `_.ary`
      *  512 - `_.flip`
      * @param {*} [thisArg] The `this` binding of `func`.
      * @param {Array} [partials] The arguments to be partially applied.
      * @param {Array} [holders] The `partials` placeholder indexes.
      * @param {Array} [argPos] The argument positions of the new function.
      * @param {number} [ary] The arity cap of `func`.
      * @param {number} [arity] The arity of `func`.
      * @returns {Function} Returns the new wrapped function.
      */
     function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
       var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
       if (!isBindKey && typeof func != 'function') {
         throw new TypeError(FUNC_ERROR_TEXT);
+      }
       var length = partials ? partials.length : 0;
       if (!length) {
         bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
         partials = holders = undefined;
+      }
       ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
       arity = arity === undefined ? arity : toInteger(arity);
       length -= holders ? holders.length : 0;
       if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
         var partialsRight = partials,
             holdersRight = holders;
         partials = holders = undefined;
+      }
       var data = isBindKey ? undefined : getData(func);
       var newData = [
         func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
         argPos, ary, arity
       ];
       if (data) {
         mergeData(newData, data);
+      }
       func = newData[0];
       bitmask = newData[1];
       thisArg = newData[2];
       partials = newData[3];
       holders = newData[4];
       arity = newData[9] = newData[9] === undefined
         ? (isBindKey ? 0 : func.length)
         : nativeMax(newData[9] - length, 0);
       if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
         bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
+      }
       if (!bitmask || bitmask == WRAP_BIND_FLAG) {
         var result = createBind(func, bitmask, thisArg);
       } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
         result = createCurry(func, bitmask, arity);
       } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
         result = createPartial(func, bitmask, thisArg, partials);
       } else {
         result = createHybrid.apply(undefined, newData);
+      }
       var setter = data ? baseSetData : setData;
       return setWrapToString(setter(result, newData), func, bitmask);
+    }
     module.exports = createWrap;

     var eq = require('./eq');
     /** Used for built-in method references. */
     var objectProto = Object.prototype;
     /** Used to check objects for own properties. */
     var hasOwnProperty = objectProto.hasOwnProperty;
     /**
      * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
      * of source objects to the destination object for all destination properties
      * that resolve to `undefined`.
+     *
      * @private
      * @param {*} objValue The destination value.
      * @param {*} srcValue The source value.
      * @param {string} key The key of the property to assign.
      * @param {Object} object The parent object of `objValue`.
      * @returns {*} Returns the value to assign.
      */
     function customDefaultsAssignIn(objValue, srcValue, key, object) {
       if (objValue === undefined ||
           (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
         return srcValue;
+      }
       return objValue;
+    }
     module.exports = customDefaultsAssignIn;

     var baseMerge = require('./_baseMerge'),
         isObject = require('./isObject');
     /**
      * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
      * objects into destination objects that are passed thru.
+     *
      * @private
      * @param {*} objValue The destination value.
      * @param {*} srcValue The source value.
      * @param {string} key The key of the property to merge.
      * @param {Object} object The parent object of `objValue`.
      * @param {Object} source The parent object of `srcValue`.
      * @param {Object} [stack] Tracks traversed source values and their merged
      *  counterparts.
      * @returns {*} Returns the value to assign.
      */
     function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
       if (isObject(objValue) && isObject(srcValue)) {
         // Recursively merge objects and arrays (susceptible to call stack limits).
         stack.set(srcValue, objValue);
         baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
         stack['delete'](srcValue);
+      }
       return objValue;
+    }
     module.exports = customDefaultsMerge;

     var isPlainObject = require('./isPlainObject');
     /**
      * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
      * objects.
+     *
      * @private
      * @param {*} value The value to inspect.
      * @param {string} key The key of the property to inspect.
      * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
      */
     function customOmitClone(value) {
       return isPlainObject(value) ? undefined : value;
+    }
     module.exports = customOmitClone;

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2020 » Webová aplikace simulující kontingenční tabulku (CIV) - VLDC

Revize 4605a44b

Přidáno uživatelem Jan Čarnogurský před více než 4 roky(ů)

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2020 » Webová aplikace simulující kontingenční tabulku (CIV) - VLDC

Revize 4605a44b

Přidáno uživatelem Jan Čarnogurský před více než 4 roky(ů)

Související úkoly