@bbn/bbn 1.0.436 → 1.0.438

package/dist/fn/object/compareConditions.js

@@ -50,19 +50,19 @@ export default function compareConditions(data, filter) {
     if (!filter.conditions || !filter.logic || !isArray(filter.conditions)) {
         throw new Error("Error in compareConditions: the filter should an abject with conditions and logic properties and conditions should be an array of objects");
     }
-    var ok = filter.logic === "AND" ? true : false;
-    each(filter.conditions, function (a) {
-        var comparator;
+    let ok = filter.logic === "AND" ? true : false;
+    each(filter.conditions, (a) => {
+        let comparator;
         if (a.conditions && isArray(a.conditions)) {
             comparator = compareConditions(data, a);
         }
         else {
             comparator = compare(getProperty(data, a.field), a.value, a.operator);
             if (comparator) {
-                var bits = a.field.split(".");
-                var prop = bits.pop();
+                let bits = a.field.split(".");
+                let prop = bits.pop();
                 if (bits.length) {
-                    each(bits, function (b) { return (data = data[b]); });
+                    each(bits, (b) => (data = data[b]));
                 }
                 // Case where both are undefined: value and prop which doesn't exist; they are not the same!
                 if (getProperty(data, prop) === undefined && a.value !== undefined) {

package/dist/fn/object/count.js

@@ -53,9 +53,7 @@ import filter from './filter.js';
  * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
  * @returns  {Number}                   The number of items
  */
-export default function count(arr, prop, val, operator) {
-    if (val === void 0) { val = null; }
-    if (operator === void 0) { operator = '='; }
+export default function count(arr, prop, val = null, operator = '=') {
     return filter(arr, prop, val, operator).length || 0;
 }
 ;

package/dist/fn/object/createObject.js

@@ -1,21 +1,8 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import extend from './extend.js';
-export default function createObject() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var obj = Object.create(null);
+export default function createObject(...args) {
+    const obj = Object.create(null);
     if (args.length) {
-        extend.apply(void 0, __spreadArray([obj], args, false));
+        extend(obj, ...args);
     }
     return obj;
 }

package/dist/fn/object/deepPath.js

@@ -56,19 +56,18 @@ import isArray from '../type/isArray.js';
  * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
  * @returns  {Number}                   The number of items
  */
-export default function deepPath(arr, filter, deepProperty, res) {
-    if (res === void 0) { res = []; }
-    var idx;
-    var start = 0;
+export default function deepPath(arr, filter, deepProperty, res = []) {
+    let idx;
+    let start = 0;
     if ((idx = search(arr, filter, start)) > -1) {
         res.push(idx);
         return res;
     }
-    each(arr, function (it, i) {
+    each(arr, (it, i) => {
         if (isArray(it[deepProperty])) {
-            var r = res.slice();
+            let r = res.slice();
             r.push(i);
-            var tmp = deepPath(it[deepProperty], filter, deepProperty, r);
+            let tmp = deepPath(it[deepProperty], filter, deepProperty, r);
             if (tmp !== false) {
                 return tmp;
             }

package/dist/fn/object/diffObj.js

@@ -4,7 +4,7 @@ import isFunction from '../type/isFunction.js';
 import isNotObject from '../type/isNotObject.js';
 import isDom from '../type/isDom.js';
 import numProperties from './numProperties.js';
-var diffObjProcessed = [];
+let diffObjProcessed = [];
 /**
   * Returns an object describing the differences for transforming the first given object into the second.
   *
@@ -82,13 +82,11 @@ var diffObjProcessed = [];
   * @param    {Boolean} notRoot
   * @returns  {Object}
   */
-export default function diffObj(obj1, obj2, unchanged, notRoot) {
-    if (unchanged === void 0) { unchanged = false; }
-    if (notRoot === void 0) { notRoot = false; }
+export default function diffObj(obj1, obj2, unchanged = false, notRoot = false) {
     if (!notRoot) {
         diffObjProcessed = [];
     }
-    var VALUE_CREATED = 'created', VALUE_UPDATED = 'updated', VALUE_DELETED = 'deleted', VALUE_UNCHANGED = 'unchanged', _compareValues = function (value1, value2) {
+    let VALUE_CREATED = 'created', VALUE_UPDATED = 'updated', VALUE_DELETED = 'deleted', VALUE_UNCHANGED = 'unchanged', _compareValues = function (value1, value2) {
         if (value1 === value2) {
             return VALUE_UNCHANGED;
         }
@@ -106,12 +104,12 @@ export default function diffObj(obj1, obj2, unchanged, notRoot) {
     if (notRoot === undefined) {
         notRoot = false;
     }
-    var diff = createObject();
+    let diff = createObject();
     if (!isFunction(obj1) && !isFunction(obj2)) {
         if (isNotObject(obj1) || isNotObject(obj2)) {
-            var res = _compareValues(obj1, obj2);
+            let res = _compareValues(obj1, obj2);
             if (unchanged || res !== VALUE_UNCHANGED) {
-                var ret = createObject();
+                let ret = createObject();
                 Object.defineProperty(ret, 'type', {
                     value: res,
                     enumerable: false,
@@ -142,24 +140,24 @@ export default function diffObj(obj1, obj2, unchanged, notRoot) {
             return false;
         }
         diffObjProcessed.push(obj1, obj2);
-        for (var key in obj1) {
+        for (let key in obj1) {
             if (isFunction(obj1[key])) {
                 continue;
             }
-            var value2 = undefined;
+            let value2 = undefined;
             if ('undefined' != typeof obj2[key]) {
                 value2 = obj2[key];
             }
-            var res = diffObj(obj1[key], value2, unchanged, true);
+            let res = diffObj(obj1[key], value2, unchanged, true);
             if (res) {
                 diff[key] = res;
             }
         }
-        for (var key in obj2) {
+        for (let key in obj2) {
             if (isFunction(obj2[key]) || 'undefined' != typeof obj1[key]) {
                 continue;
             }
-            var res = diffObj(undefined, obj2[key], unchanged, true);
+            let res = diffObj(undefined, obj2[key], unchanged, true);
             if (res) {
                 diff[key] = res;
             }

package/dist/fn/object/extend.js

@@ -87,14 +87,10 @@ import isObject from '../type/isObject.js';
  * @memberof bbn.fn
  * @returns  {Object} The first object argument, merged with the other objects given
  */
-export default function extend() {
-    var originalArgs = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        originalArgs[_i] = arguments[_i];
-    }
-    var deep = false;
-    var args = [];
-    for (var i = 0; i < originalArgs.length; i++) {
+export default function extend(...originalArgs) {
+    let deep = false;
+    let args = [];
+    for (let i = 0; i < originalArgs.length; i++) {
         if (originalArgs[i] === true) {
             deep = true;
         }
@@ -111,16 +107,16 @@ export default function extend() {
     if (!args.length) {
         throw new Error("No argument given");
     }
-    var out = args[0];
-    var hasNoData;
-    for (var i = 1; i < args.length; i++) {
-        iterate(args[i], function (a, key) {
+    let out = args[0];
+    let hasNoData;
+    for (let i = 1; i < args.length; i++) {
+        iterate(args[i], (a, key) => {
             if (deep) {
                 if (isArray(a)) {
                     out[key] = isArray(out[key]) ? out[key] : [];
-                    each(a, function (b, i) {
+                    each(a, (b, i) => {
                         if (b && typeof b === "object") {
-                            var tmp = out[key][i];
+                            let tmp = out[key][i];
                             if (isArray(b)) {
                                 if (!isArray(tmp)) {
                                     tmp = [];

package/dist/fn/object/extendOut.js

@@ -15,14 +15,9 @@ import isObject from '../type/isObject.js';
  * @memberof bbn.fn
  * @returns  {Object}
  */
-export default function extendOut() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var r = null;
-    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
-        var a = args_1[_a];
+export default function extendOut(...args) {
+    let r = null;
+    for (let a of args) {
         if (!isObject(a)) {
             throw new Error("Each argument for extendOut must be an object, " + typeof a + " given");
         }
@@ -30,7 +25,7 @@ export default function extendOut() {
             r = a;
         }
         else {
-            for (var n in a) {
+            for (let n in a) {
                 if (isObject(r[n], a[n])) {
                     extendOut(r[n], a[n]);
                 }

package/dist/fn/object/filter.js

@@ -48,16 +48,14 @@ import compareConditions from './compareConditions.js';
  * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
  * @returns  {Array}                    A new filtered array
  */
-export default function filter(arr, prop, val, operator) {
-    if (val === void 0) { val = null; }
-    if (operator === void 0) { operator = '='; }
+export default function filter(arr, prop, val = null, operator = '=') {
     if (!isArray(arr)) {
         bbn.fn.log("NOT ARRAY", arr);
         throw new Error('Error in filter: The first argument must be an array');
     }
-    var cfg = {};
-    var res = [];
-    var isFn = typeof (prop) === 'function';
+    let cfg = {};
+    const res = [];
+    const isFn = typeof (prop) === 'function';
     if (!prop || !arr.length) {
         return arr;
     }
@@ -72,20 +70,16 @@ export default function filter(arr, prop, val, operator) {
         throw new Error('Search function error: The prop argument should be a string or an object');
     }
     if (typeof (prop) === 'function') {
-        for (var i = 0; i < arr.length; i++) {
-            bbn.env._enumerated.push(true);
+        for (let i = 0; i < arr.length; i++) {
             if (prop(arr[i], i)) {
-                bbn.env._enumerated.pop();
                 res.push(arr[i]);
-                bbn.env._enumerated.push(true);
             }
-            bbn.env._enumerated.pop();
         }
     }
     else {
         cfg = filterToConditions(cfg, operator);
         if (cfg.conditions && cfg.logic) {
-            for (var i = 0; i < arr.length; i++) {
+            for (let i = 0; i < arr.length; i++) {
                 if (compareConditions(arr[i], cfg)) {
                     res.push(arr[i]);
                 }

package/dist/fn/object/filterToConditions.js

@@ -38,19 +38,18 @@ import iterate from '../loop/iterate.js';
  * @param    {String} operator
  * @returns  {Object}
  */
-export default function filterToConditions(filter, operator) {
-    if (operator === void 0) { operator = "="; }
+export default function filterToConditions(filter, operator = "=") {
     if (!isObject(filter)) {
         throw new Error("Error in filterToCondition: filter must be an object");
     }
     if (!filter.conditions || !isArray(filter.conditions)) {
-        var tmp_1 = [];
-        iterate(filter, function (a, n) {
+        let tmp = [];
+        iterate(filter, (a, n) => {
             if (isObject(a) && typeof a.conditions === "object") {
-                tmp_1.push(filterToConditions(a));
+                tmp.push(filterToConditions(a));
             }
             else {
-                tmp_1.push({
+                tmp.push({
                     field: n,
                     operator: operator,
                     value: a,
@@ -58,7 +57,7 @@ export default function filterToConditions(filter, operator) {
             }
         });
         filter = {
-            conditions: tmp_1,
+            conditions: tmp,
         };
     }
     if (!filter.logic) {

package/dist/fn/object/findAll.js

@@ -56,15 +56,14 @@ import isArray from '../type/isArray.js';
  * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
  * @returns  {Number}                   The number of items
  */
-export default function findAll(arr, filter, deepProperty, res) {
-    if (res === void 0) { res = []; }
-    var idx;
-    var start = 0;
+export default function findAll(arr, filter, deepProperty, res = []) {
+    let idx;
+    let start = 0;
     while ((idx = search(arr, filter, start)) > -1) {
         res.push(arr[idx]);
         start = idx + 1;
     }
-    each(arr, function (it) {
+    each(arr, (it) => {
         if (isArray(it[deepProperty])) {
             findAll(it[deepProperty], filter, deepProperty, res);
         }

package/dist/fn/object/getField.js

@@ -29,14 +29,8 @@ import getRow from './getRow.js';
  * @param    {Boolean}                  backward  Searches backward
  * @returns  {*}
  */
-export default function getField(arr, field, prop, val, operator, from, backward, notFound) {
-    if (prop === void 0) { prop = ''; }
-    if (val === void 0) { val = null; }
-    if (operator === void 0) { operator = '='; }
-    if (from === void 0) { from = 0; }
-    if (backward === void 0) { backward = false; }
-    if (notFound === void 0) { notFound = undefined; }
-    var r;
+export default function getField(arr, field, prop = '', val = null, operator = '=', from = 0, backward = false, notFound = undefined) {
+    let r;
     if (prop && ['object', 'function'].includes(typeof prop) && (6 in arguments)) {
         notFound = backward;
     }

package/dist/fn/object/getFieldValues.js

@@ -34,8 +34,8 @@ export default function getFieldValues(arr, field, prop, val, operator) {
     if (prop) {
         arr = _filter(arr, prop, val, operator);
     }
-    var res = [];
-    each(arr, function (a) { return (res.indexOf(a[field]) === -1 ? res.push(a[field]) : null); });
+    let res = [];
+    each(arr, (a) => (res.indexOf(a[field]) === -1 ? res.push(a[field]) : null));
     return res;
 }
 ;

package/dist/fn/object/getProperty.js

@@ -26,20 +26,16 @@
  * @param    {String} props
  * @returns  {*}      The property's value or undefined
  */
-export default function getProperty(obj) {
-    var props = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        props[_i - 1] = arguments[_i];
-    }
+export default function getProperty(obj, ...props) {
     if (typeof obj === 'object') {
-        var arr = [];
+        const arr = [];
         if (props.length === 1 && typeof props[0] === 'string') {
-            arr.push.apply(arr, props[0].split('.'));
+            arr.push(...props[0].split('.'));
         }
         else {
-            arr.push.apply(arr, props);
+            arr.push(...props);
         }
-        return arr.reduce(function (o, i) {
+        return arr.reduce((o, i) => {
             if (o) {
                 return o[o instanceof Array ? parseInt(i) : i];
             }

package/dist/fn/object/getRow.js

@@ -42,13 +42,8 @@ import search from './search.js';
  * @param    {*}                        notFound  Value to return when not found
  * @returns  {*}           The item if found, false otherwise
  */
-export default function getRow(arr, prop, val, operator, from, backward, notFound) {
-    if (val === void 0) { val = null; }
-    if (operator === void 0) { operator = '='; }
-    if (from === void 0) { from = 0; }
-    if (backward === void 0) { backward = false; }
-    if (notFound === void 0) { notFound = false; }
-    var idx = search(arr, prop, val, operator, from, backward);
+export default function getRow(arr, prop, val = null, operator = '=', from = 0, backward = false, notFound = false) {
+    let idx = search(arr, prop, val, operator, from, backward);
     if (idx > -1) {
         return arr[idx];
     }

package/dist/fn/object/getSortingMoves.js

@@ -19,12 +19,12 @@
  * @returns  {Array}  The same array, with elements repositionned.
  */
 // LIS indices on `pos` (strictly increasing)
-var lisIndices = function (arr) {
-    var n = arr.length, tails = [], prev = Array(n).fill(-1);
-    for (var i = 0; i < n; i++) {
-        var x = arr[i], lo = 0, hi = tails.length;
+const lisIndices = (arr) => {
+    const n = arr.length, tails = [], prev = Array(n).fill(-1);
+    for (let i = 0; i < n; i++) {
+        let x = arr[i], lo = 0, hi = tails.length;
         while (lo < hi) {
-            var mid = (lo + hi) >> 1;
+            const mid = (lo + hi) >> 1;
             if (arr[tails[mid]] < x)
                 lo = mid + 1;
             else
@@ -34,8 +34,8 @@ var lisIndices = function (arr) {
             prev[i] = tails[lo - 1];
         tails[lo] = i;
     }
-    var res = [];
-    for (var k = tails.length ? tails[tails.length - 1] : -1; k !== -1; k = prev[k])
+    const res = [];
+    for (let k = tails.length ? tails[tails.length - 1] : -1; k !== -1; k = prev[k])
         res.push(k);
     return res.reverse();
 };
@@ -43,53 +43,53 @@ export default function getSortingMoves(src, dst) {
     if (src.length !== dst.length)
         throw new Error("Lengths must match.");
     // Validate same unique set
-    var setDst = new Set(dst);
+    const setDst = new Set(dst);
     if (setDst.size !== dst.length)
         throw new Error("dst has duplicates.");
-    var setSrc = new Set(src);
+    const setSrc = new Set(src);
     if (setSrc.size !== src.length)
         throw new Error("src has duplicates.");
-    if (src.length !== setDst.size || Array.from(setSrc).some(function (v) { return !setDst.has(v); })) {
+    if (src.length !== setDst.size || Array.from(setSrc).some(v => !setDst.has(v))) {
         throw new Error("Arrays must contain the same unique values.");
     }
     // Map each value to its index in dst
-    var posInDst = new Map(dst.map(function (v, i) { return [v, i]; }));
+    const posInDst = new Map(dst.map((v, i) => [v, i]));
     // Convert src into positions-in-dst
-    var pos = src.map(function (v) { return posInDst.get(v); });
-    var lisIdx = lisIndices(pos);
-    var keepSet = new Set(lisIdx.map(function (i) { return src[i]; })); // values we won't move
+    const pos = src.map(v => posInDst.get(v));
+    const lisIdx = lisIndices(pos);
+    const keepSet = new Set(lisIdx.map(i => src[i])); // values we won't move
     // Next kept anchor to the right for each dst index
-    var nextKeptAfter = Array(dst.length).fill(-1);
-    for (var i = dst.length - 2; i >= 0; i--) {
+    const nextKeptAfter = Array(dst.length).fill(-1);
+    for (let i = dst.length - 2; i >= 0; i--) {
         nextKeptAfter[i] = nextKeptAfter[i + 1];
         if (keepSet.has(dst[i + 1]))
             nextKeptAfter[i] = i + 1;
     }
     // Simulate moves on a working copy
-    var work = src.slice();
-    var indexOf = new Map(work.map(function (v, i) { return [v, i]; }));
-    var moves = [];
-    for (var i = 0; i < dst.length; i++) {
-        var v = dst[i];
+    const work = src.slice();
+    const indexOf = new Map(work.map((v, i) => [v, i]));
+    const moves = [];
+    for (let i = 0; i < dst.length; i++) {
+        const v = dst[i];
         if (keepSet.has(v))
             continue; // leave in place
-        var from = indexOf.get(v);
+        const from = indexOf.get(v);
         if (from === undefined) {
             throw new Error("Inconsistent state");
         }
-        var j = nextKeptAfter[i];
-        var to = (j !== -1) ? indexOf.get(dst[j]) : work.length;
+        const j = nextKeptAfter[i];
+        const to = (j !== -1) ? indexOf.get(dst[j]) : work.length;
         if (to === undefined) {
             throw new Error("Inconsistent state");
         }
-        var adjustedTo = from < to ? to - 1 : to;
+        const adjustedTo = from < to ? to - 1 : to;
         if (from !== adjustedTo) {
-            var moved = work.splice(from, 1)[0];
+            const [moved] = work.splice(from, 1);
             work.splice(adjustedTo, 0, moved);
-            moves.push({ from: from, to: adjustedTo, value: v });
+            moves.push({ from, to: adjustedTo, value: v });
             // refresh indices (simple & reliable)
             indexOf.clear();
-            for (var p = 0; p < work.length; p++)
+            for (let p = 0; p < work.length; p++)
                 indexOf.set(work[p], p);
         }
     }

package/dist/fn/object/isWritable.js

@@ -36,7 +36,7 @@
   * @returns  {Boolean}
   */
 export default function isWritable(obj, key) {
-    var desc;
+    let desc;
     while (obj) {
         desc = Object.getOwnPropertyDescriptor(obj, key);
         if (desc) {

package/dist/fn/object/map.js

@@ -71,9 +71,8 @@ import isArray from '../type/isArray.js';
  * @param    {Number}   level
  * @returns  {Array}
  */
-export default function map(arr, fn, deepProp, level) {
-    if (level === void 0) { level = 0; }
-    return arr.map(function (a, i) {
+export default function map(arr, fn, deepProp, level = 0) {
+    return arr.map((a, i) => {
         a = fn(a, i, level);
         if (deepProp && a[deepProp] && isArray(a[deepProp])) {
             a[deepProp] = map(a[deepProp], fn, deepProp, level + 1);

package/dist/fn/object/move.js

@@ -32,7 +32,7 @@
  */
 export default function move(arr, fromIndex, toIndex) {
     if (toIndex >= arr.length) {
-        var k = toIndex - arr.length;
+        let k = toIndex - arr.length;
         while (k-- + 1) {
             arr.push(undefined);
         }

package/dist/fn/object/multiorder.js

@@ -41,7 +41,7 @@ export default function multiorder(arr, orders) {
     if (!orders) {
         return arr;
     }
-    var currentOrders;
+    let currentOrders;
     if (!Array.isArray(orders) && typeof orders === 'object') {
         currentOrders = [];
         for (var n in orders) {
@@ -54,11 +54,10 @@ export default function multiorder(arr, orders) {
     if (!Array.isArray(currentOrders)) {
         throw new Error('The orders argument must be an array');
     }
-    var r = arr.slice();
-    return r.sort(function (a, b) {
-        var res;
-        for (var _i = 0, currentOrders_1 = currentOrders; _i < currentOrders_1.length; _i++) {
-            var order = currentOrders_1[_i];
+    let r = arr.slice();
+    return r.sort((a, b) => {
+        let res;
+        for (let order of currentOrders) {
             res = _compareValues(a, b, order.field, order.dir);
             if (res !== 0) {
                 return res;

package/dist/fn/object/mutateArray.js

@@ -3,8 +3,7 @@ import hash from '../string/hash.js';
 import isSame from '../type/isSame.js';
 import search from './search.js';
 import checkType from '../type/checkType.js';
-export default function mutateArray(a1, a2, hashFn) {
-    if (hashFn === void 0) { hashFn = null; }
+export default function mutateArray(a1, a2, hashFn = null) {
     if (!isArray(a1, a2)) {
         throw new TypeError('mutateArray can only be called with arrays');
     }
@@ -14,27 +13,27 @@ export default function mutateArray(a1, a2, hashFn) {
     else {
         checkType(hashFn, 'function', 'The hash function must be a function');
     }
-    var mapA2 = new Map(a2.map(function (item) { return [hashFn(item), item]; }));
-    var a1Ordered = [];
+    const mapA2 = new Map(a2.map(item => [hashFn(item), item]));
+    let a1Ordered = [];
     // Build a1Ordered to have the same order and contents as a2
-    a2.forEach(function (item) {
+    a2.forEach(item => {
         a1Ordered.push(item);
     });
     // Remove items from a1 that are not in a2
-    var i = a1.length;
+    let i = a1.length;
     while (i--) {
         if (!mapA2.has(hashFn(a1[i]))) {
             a1.splice(i, 1);
         }
     }
     // Insert or move items to match the order of a2
-    for (var j = 0; j < a1Ordered.length; j++) {
+    for (let j = 0; j < a1Ordered.length; j++) {
         if ((j >= a1.length) || !isSame(a1[j], a1Ordered[j])) {
             // Find the index of the item in a1, if it exists
-            var indexInA1 = search(a1, a1Ordered[j]);
+            const indexInA1 = search(a1, a1Ordered[j]);
             if (indexInA1 !== -1) {
                 // Move the item to the correct position if it already exists in a1
-                var itemToMove = a1.splice(indexInA1, 1)[0];
+                const [itemToMove] = a1.splice(indexInA1, 1);
                 a1.splice(j, 0, itemToMove);
             }
             else {

package/dist/fn/object/mutateObject.js

@@ -12,14 +12,14 @@ export default function mutateObject(a1, a2, hashFn) {
     else {
         hashFn = hash;
     }
-    var mapA2 = Object.keys(a2);
+    const mapA2 = Object.keys(a2);
     // Remove items from a1 that are not in a2
-    for (var n in a1) {
+    for (let n in a1) {
         if (!mapA2.includes(n)) {
             delete a1[n];
         }
     }
-    mapA2.forEach(function (n) {
+    mapA2.forEach(n => {
         if (!isSame(a1[n], a2[n])) {
             a1[n] = a2[n];
         }

package/dist/fn/object/order.js

@@ -25,8 +25,7 @@ import _compareValues from './_compareValues.js';
  * @param    {String} [dir=asc] The direction of the order (desc or asc by default)
  * @returns  {Array}
  */
-export default function order(arr, prop, dir) {
-    if (dir === void 0) { dir = 'asc'; }
+export default function order(arr, prop, dir = 'asc') {
     if (arr) {
         return arr.sort(function (a, b) {
             return _compareValues(a, b, prop, dir);