locutus 2.0.32 → 2.0.35

package/php/array/array_multisort.js

@@ -1,7 +1,3 @@
-'use strict';
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
 module.exports = function array_multisort(arr) {
   //  discuss at: https://locutus.io/php/array_multisort/
   // original by: Theriault (https://github.com/Theriault)
@@ -24,190 +20,203 @@ module.exports = function array_multisort(arr) {
   //      note 1: bits: HGFE DCBA
   //      note 1: args: Holds pointer to arguments for reassignment
 
-  var g = void 0;
-  var i = void 0;
-  var j = void 0;
-  var k = void 0;
-  var l = void 0;
-  var sal = void 0;
-  var vkey = void 0;
-  var elIndex = void 0;
-  var lastSorts = void 0;
-  var tmpArray = void 0;
-  var zlast = void 0;
+  let g
+  let i
+  let j
+  let k
+  let l
+  let sal
+  let vkey
+  let elIndex
+  let lastSorts
+  let tmpArray
+  let zlast
 
-  var sortFlag = [0];
-  var thingsToSort = [];
-  var nLastSort = [];
-  var lastSort = [];
+  const sortFlag = [0]
+  const thingsToSort = []
+  let nLastSort = []
+  let lastSort = []
   // possibly redundant
-  var args = arguments;
+  const args = arguments
 
-  var flags = {
+  const flags = {
     SORT_REGULAR: 16,
     SORT_NUMERIC: 17,
     SORT_STRING: 18,
     SORT_ASC: 32,
-    SORT_DESC: 40
-  };
+    SORT_DESC: 40,
+  }
 
-  var sortDuplicator = function sortDuplicator(a, b) {
-    return nLastSort.shift();
-  };
+  const sortDuplicator = function (a, b) {
+    return nLastSort.shift()
+  }
 
-  var sortFunctions = [[function (a, b) {
-    lastSort.push(a > b ? 1 : a < b ? -1 : 0);
-    return a > b ? 1 : a < b ? -1 : 0;
-  }, function (a, b) {
-    lastSort.push(b > a ? 1 : b < a ? -1 : 0);
-    return b > a ? 1 : b < a ? -1 : 0;
-  }], [function (a, b) {
-    lastSort.push(a - b);
-    return a - b;
-  }, function (a, b) {
-    lastSort.push(b - a);
-    return b - a;
-  }], [function (a, b) {
-    lastSort.push(a + '' > b + '' ? 1 : a + '' < b + '' ? -1 : 0);
-    return a + '' > b + '' ? 1 : a + '' < b + '' ? -1 : 0;
-  }, function (a, b) {
-    lastSort.push(b + '' > a + '' ? 1 : b + '' < a + '' ? -1 : 0);
-    return b + '' > a + '' ? 1 : b + '' < a + '' ? -1 : 0;
-  }]];
+  const sortFunctions = [
+    [
+      function (a, b) {
+        lastSort.push(a > b ? 1 : a < b ? -1 : 0)
+        return a > b ? 1 : a < b ? -1 : 0
+      },
+      function (a, b) {
+        lastSort.push(b > a ? 1 : b < a ? -1 : 0)
+        return b > a ? 1 : b < a ? -1 : 0
+      },
+    ],
+    [
+      function (a, b) {
+        lastSort.push(a - b)
+        return a - b
+      },
+      function (a, b) {
+        lastSort.push(b - a)
+        return b - a
+      },
+    ],
+    [
+      function (a, b) {
+        lastSort.push(a + '' > b + '' ? 1 : a + '' < b + '' ? -1 : 0)
+        return a + '' > b + '' ? 1 : a + '' < b + '' ? -1 : 0
+      },
+      function (a, b) {
+        lastSort.push(b + '' > a + '' ? 1 : b + '' < a + '' ? -1 : 0)
+        return b + '' > a + '' ? 1 : b + '' < a + '' ? -1 : 0
+      },
+    ],
+  ]
 
-  var sortArrs = [[]];
+  const sortArrs = [[]]
 
-  var sortKeys = [[]];
+  const sortKeys = [[]]
 
   // Store first argument into sortArrs and sortKeys if an Object.
   // First Argument should be either a Javascript Array or an Object,
   // otherwise function would return FALSE like in PHP
-  if (Object.prototype.toString.call(arr) === '[object Array]') {
-    sortArrs[0] = arr;
-  } else if (arr && (typeof arr === 'undefined' ? 'undefined' : _typeof(arr)) === 'object') {
+  if (Array.isArray(arr)) {
+    sortArrs[0] = arr
+  } else if (arr && typeof arr === 'object') {
     for (i in arr) {
       if (arr.hasOwnProperty(i)) {
-        sortKeys[0].push(i);
-        sortArrs[0].push(arr[i]);
+        sortKeys[0].push(i)
+        sortArrs[0].push(arr[i])
       }
     }
   } else {
-    return false;
+    return false
   }
 
   // arrMainLength: Holds the length of the first array.
   // All other arrays must be of equal length, otherwise function would return FALSE like in PHP
   // sortComponents: Holds 2 indexes per every section of the array
   // that can be sorted. As this is the start, the whole array can be sorted.
-  var arrMainLength = sortArrs[0].length;
-  var sortComponents = [0, arrMainLength];
+  const arrMainLength = sortArrs[0].length
+  let sortComponents = [0, arrMainLength]
 
   // Loop through all other arguments, checking lengths and sort flags
   // of arrays and adding them to the above variables.
-  var argl = arguments.length;
+  const argl = arguments.length
   for (j = 1; j < argl; j++) {
-    if (Object.prototype.toString.call(arguments[j]) === '[object Array]') {
-      sortArrs[j] = arguments[j];
-      sortFlag[j] = 0;
+    if (Array.isArray(arguments[j])) {
+      sortArrs[j] = arguments[j]
+      sortFlag[j] = 0
       if (arguments[j].length !== arrMainLength) {
-        return false;
+        return false
       }
-    } else if (arguments[j] && _typeof(arguments[j]) === 'object') {
-      sortKeys[j] = [];
-      sortArrs[j] = [];
-      sortFlag[j] = 0;
+    } else if (arguments[j] && typeof arguments[j] === 'object') {
+      sortKeys[j] = []
+      sortArrs[j] = []
+      sortFlag[j] = 0
       for (i in arguments[j]) {
         if (arguments[j].hasOwnProperty(i)) {
-          sortKeys[j].push(i);
-          sortArrs[j].push(arguments[j][i]);
+          sortKeys[j].push(i)
+          sortArrs[j].push(arguments[j][i])
         }
       }
       if (sortArrs[j].length !== arrMainLength) {
-        return false;
+        return false
       }
     } else if (typeof arguments[j] === 'string') {
-      var lFlag = sortFlag.pop();
+      const lFlag = sortFlag.pop()
       // Keep extra parentheses around latter flags check
       // to avoid minimization leading to CDATA closer
-      if (typeof flags[arguments[j]] === 'undefined' || (flags[arguments[j]] >>> 4 & lFlag >>> 4) > 0) {
-        return false;
+      if (typeof flags[arguments[j]] === 'undefined' || ((flags[arguments[j]] >>> 4) & (lFlag >>> 4)) > 0) {
+        return false
       }
-      sortFlag.push(lFlag + flags[arguments[j]]);
+      sortFlag.push(lFlag + flags[arguments[j]])
     } else {
-      return false;
+      return false
     }
   }
 
   for (i = 0; i !== arrMainLength; i++) {
-    thingsToSort.push(true);
+    thingsToSort.push(true)
   }
 
   // Sort all the arrays....
   for (i in sortArrs) {
     if (sortArrs.hasOwnProperty(i)) {
-      lastSorts = [];
-      tmpArray = [];
-      elIndex = 0;
-      nLastSort = [];
-      lastSort = [];
+      lastSorts = []
+      tmpArray = []
+      elIndex = 0
+      nLastSort = []
+      lastSort = []
 
       // If there are no sortComponents, then no more sorting is neeeded.
       // Copy the array back to the argument.
       if (sortComponents.length === 0) {
-        if (Object.prototype.toString.call(arguments[i]) === '[object Array]') {
-          args[i] = sortArrs[i];
+        if (Array.isArray(arguments[i])) {
+          args[i] = sortArrs[i]
         } else {
           for (k in arguments[i]) {
             if (arguments[i].hasOwnProperty(k)) {
-              delete arguments[i][k];
+              delete arguments[i][k]
             }
           }
-          sal = sortArrs[i].length;
+          sal = sortArrs[i].length
           for (j = 0, vkey = 0; j < sal; j++) {
-            vkey = sortKeys[i][j];
-            args[i][vkey] = sortArrs[i][j];
+            vkey = sortKeys[i][j]
+            args[i][vkey] = sortArrs[i][j]
           }
         }
-        sortArrs.splice(i, 1);
-        sortKeys.splice(i, 1);
-        continue;
+        sortArrs.splice(i, 1)
+        sortKeys.splice(i, 1)
+        continue
       }
 
       // Sort function for sorting. Either sorts asc or desc, regular/string or numeric.
-      var sFunction = sortFunctions[sortFlag[i] & 3][(sortFlag[i] & 8) > 0 ? 1 : 0];
+      let sFunction = sortFunctions[sortFlag[i] & 3][(sortFlag[i] & 8) > 0 ? 1 : 0]
 
       // Sort current array.
       for (l = 0; l !== sortComponents.length; l += 2) {
-        tmpArray = sortArrs[i].slice(sortComponents[l], sortComponents[l + 1] + 1);
-        tmpArray.sort(sFunction);
+        tmpArray = sortArrs[i].slice(sortComponents[l], sortComponents[l + 1] + 1)
+        tmpArray.sort(sFunction)
         // Is there a better way to copy an array in Javascript?
-        lastSorts[l] = [].concat(lastSort);
-        elIndex = sortComponents[l];
+        lastSorts[l] = [].concat(lastSort)
+        elIndex = sortComponents[l]
         for (g in tmpArray) {
           if (tmpArray.hasOwnProperty(g)) {
-            sortArrs[i][elIndex] = tmpArray[g];
-            elIndex++;
+            sortArrs[i][elIndex] = tmpArray[g]
+            elIndex++
           }
         }
       }
 
       // Duplicate the sorting of the current array on future arrays.
-      sFunction = sortDuplicator;
+      sFunction = sortDuplicator
       for (j in sortArrs) {
         if (sortArrs.hasOwnProperty(j)) {
           if (sortArrs[j] === sortArrs[i]) {
-            continue;
+            continue
           }
           for (l = 0; l !== sortComponents.length; l += 2) {
-            tmpArray = sortArrs[j].slice(sortComponents[l], sortComponents[l + 1] + 1);
+            tmpArray = sortArrs[j].slice(sortComponents[l], sortComponents[l + 1] + 1)
             // alert(l + ':' + nLastSort);
-            nLastSort = [].concat(lastSorts[l]);
-            tmpArray.sort(sFunction);
-            elIndex = sortComponents[l];
+            nLastSort = [].concat(lastSorts[l])
+            tmpArray.sort(sFunction)
+            elIndex = sortComponents[l]
             for (g in tmpArray) {
               if (tmpArray.hasOwnProperty(g)) {
-                sortArrs[j][elIndex] = tmpArray[g];
-                elIndex++;
+                sortArrs[j][elIndex] = tmpArray[g]
+                elIndex++
               }
             }
           }
@@ -218,14 +227,14 @@ module.exports = function array_multisort(arr) {
       for (j in sortKeys) {
         if (sortKeys.hasOwnProperty(j)) {
           for (l = 0; l !== sortComponents.length; l += 2) {
-            tmpArray = sortKeys[j].slice(sortComponents[l], sortComponents[l + 1] + 1);
-            nLastSort = [].concat(lastSorts[l]);
-            tmpArray.sort(sFunction);
-            elIndex = sortComponents[l];
+            tmpArray = sortKeys[j].slice(sortComponents[l], sortComponents[l + 1] + 1)
+            nLastSort = [].concat(lastSorts[l])
+            tmpArray.sort(sFunction)
+            elIndex = sortComponents[l]
             for (g in tmpArray) {
               if (tmpArray.hasOwnProperty(g)) {
-                sortKeys[j][elIndex] = tmpArray[g];
-                elIndex++;
+                sortKeys[j][elIndex] = tmpArray[g]
+                elIndex++
               }
             }
           }
@@ -233,57 +242,56 @@ module.exports = function array_multisort(arr) {
       }
 
       // Generate the next sortComponents
-      zlast = null;
-      sortComponents = [];
+      zlast = null
+      sortComponents = []
       for (j in sortArrs[i]) {
         if (sortArrs[i].hasOwnProperty(j)) {
           if (!thingsToSort[j]) {
             if (sortComponents.length & 1) {
-              sortComponents.push(j - 1);
+              sortComponents.push(j - 1)
             }
-            zlast = null;
-            continue;
+            zlast = null
+            continue
           }
           if (!(sortComponents.length & 1)) {
             if (zlast !== null) {
               if (sortArrs[i][j] === zlast) {
-                sortComponents.push(j - 1);
+                sortComponents.push(j - 1)
               } else {
-                thingsToSort[j] = false;
+                thingsToSort[j] = false
               }
             }
-            zlast = sortArrs[i][j];
+            zlast = sortArrs[i][j]
           } else {
             if (sortArrs[i][j] !== zlast) {
-              sortComponents.push(j - 1);
-              zlast = sortArrs[i][j];
+              sortComponents.push(j - 1)
+              zlast = sortArrs[i][j]
             }
           }
         }
       }
 
       if (sortComponents.length & 1) {
-        sortComponents.push(j);
+        sortComponents.push(j)
       }
-      if (Object.prototype.toString.call(arguments[i]) === '[object Array]') {
-        args[i] = sortArrs[i];
+      if (Array.isArray(arguments[i])) {
+        args[i] = sortArrs[i]
       } else {
         for (j in arguments[i]) {
           if (arguments[i].hasOwnProperty(j)) {
-            delete arguments[i][j];
+            delete arguments[i][j]
           }
         }
 
-        sal = sortArrs[i].length;
+        sal = sortArrs[i].length
         for (j = 0, vkey = 0; j < sal; j++) {
-          vkey = sortKeys[i][j];
-          args[i][vkey] = sortArrs[i][j];
+          vkey = sortKeys[i][j]
+          args[i][vkey] = sortArrs[i][j]
         }
       }
-      sortArrs.splice(i, 1);
-      sortKeys.splice(i, 1);
+      sortArrs.splice(i, 1)
+      sortKeys.splice(i, 1)
     }
   }
-  return true;
-};
-//# sourceMappingURL=array_multisort.js.map
+  return true
+}

package/php/array/array_pad.js

@@ -1,37 +1,35 @@
-'use strict';
-
 module.exports = function array_pad(input, padSize, padValue) {
-  //  discuss at: https://locutus.io/php/array_pad/
-  // original by: Waldo Malqui Silva (https://waldo.malqui.info)
-  //   example 1: array_pad([ 7, 8, 9 ], 2, 'a')
-  //   returns 1: [ 7, 8, 9]
-  //   example 2: array_pad([ 7, 8, 9 ], 5, 'a')
-  //   returns 2: [ 7, 8, 9, 'a', 'a']
-  //   example 3: array_pad([ 7, 8, 9 ], 5, 2)
-  //   returns 3: [ 7, 8, 9, 2, 2]
-  //   example 4: array_pad([ 7, 8, 9 ], -5, 'a')
-  //   returns 4: [ 'a', 'a', 7, 8, 9 ]
+  //      discuss at: https://locutus.io/php/array_pad/
+  // parity verified: PHP 8.3
+  //     original by: Waldo Malqui Silva (https://waldo.malqui.info)
+  //       example 1: array_pad([ 7, 8, 9 ], 2, 'a')
+  //       returns 1: [ 7, 8, 9]
+  //       example 2: array_pad([ 7, 8, 9 ], 5, 'a')
+  //       returns 2: [ 7, 8, 9, 'a', 'a']
+  //       example 3: array_pad([ 7, 8, 9 ], 5, 2)
+  //       returns 3: [ 7, 8, 9, 2, 2]
+  //       example 4: array_pad([ 7, 8, 9 ], -5, 'a')
+  //       returns 4: [ 'a', 'a', 7, 8, 9 ]
 
-  var pad = [];
-  var newArray = [];
-  var newLength = void 0;
-  var diff = 0;
-  var i = 0;
+  let pad = []
+  const newArray = []
+  let newLength
+  let diff = 0
+  let i = 0
 
-  if (Object.prototype.toString.call(input) === '[object Array]' && !isNaN(padSize)) {
-    newLength = padSize < 0 ? padSize * -1 : padSize;
-    diff = newLength - input.length;
+  if (Array.isArray(input) && !isNaN(padSize)) {
+    newLength = padSize < 0 ? padSize * -1 : padSize
+    diff = newLength - input.length
 
     if (diff > 0) {
       for (i = 0; i < diff; i++) {
-        newArray[i] = padValue;
+        newArray[i] = padValue
       }
-      pad = padSize < 0 ? newArray.concat(input) : input.concat(newArray);
+      pad = padSize < 0 ? newArray.concat(input) : input.concat(newArray)
     } else {
-      pad = input;
+      pad = input
     }
   }
 
-  return pad;
-};
-//# sourceMappingURL=array_pad.js.map
+  return pad
+}

package/php/array/array_pop.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function array_pop(inputArr) {
   //  discuss at: https://locutus.io/php/array_pop/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -21,30 +19,29 @@ module.exports = function array_pop(inputArr) {
   //   example 2: var $result = $data
   //   returns 2: {firstName: 'Kevin'}
 
-  var key = '';
-  var lastKey = '';
+  let key = ''
+  let lastKey = ''
 
   if (inputArr.hasOwnProperty('length')) {
     // Indexed
     if (!inputArr.length) {
       // Done popping, are we?
-      return null;
+      return null
     }
-    return inputArr.pop();
+    return inputArr.pop()
   } else {
     // Associative
     for (key in inputArr) {
       if (inputArr.hasOwnProperty(key)) {
-        lastKey = key;
+        lastKey = key
       }
     }
     if (lastKey) {
-      var tmp = inputArr[lastKey];
-      delete inputArr[lastKey];
-      return tmp;
+      const tmp = inputArr[lastKey]
+      delete inputArr[lastKey]
+      return tmp
     } else {
-      return null;
+      return null
     }
   }
-};
-//# sourceMappingURL=array_pop.js.map
+}

package/php/array/array_product.js

@@ -1,25 +1,23 @@
-'use strict';
-
 module.exports = function array_product(input) {
-  //  discuss at: https://locutus.io/php/array_product/
-  // original by: Waldo Malqui Silva (https://waldo.malqui.info)
-  //   example 1: array_product([ 2, 4, 6, 8 ])
-  //   returns 1: 384
+  //      discuss at: https://locutus.io/php/array_product/
+  // parity verified: PHP 8.3
+  //     original by: Waldo Malqui Silva (https://waldo.malqui.info)
+  //       example 1: array_product([ 2, 4, 6, 8 ])
+  //       returns 1: 384
 
-  var idx = 0;
-  var product = 1;
-  var il = 0;
+  let idx = 0
+  let product = 1
+  let il = 0
 
-  if (Object.prototype.toString.call(input) !== '[object Array]') {
-    return null;
+  if (!Array.isArray(input)) {
+    return null
   }
 
-  il = input.length;
+  il = input.length
   while (idx < il) {
-    product *= !isNaN(input[idx]) ? input[idx] : 0;
-    idx++;
+    product *= !isNaN(input[idx]) ? input[idx] : 0
+    idx++
   }
 
-  return product;
-};
-//# sourceMappingURL=array_product.js.map
+  return product
+}

package/php/array/array_push.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function array_push(inputArr) {
   //  discuss at: https://locutus.io/php/array_push/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -12,36 +10,35 @@ module.exports = function array_push(inputArr) {
   //   example 1: array_push(['kevin','van'], 'zonneveld')
   //   returns 1: 3
 
-  var i = 0;
-  var pr = '';
-  var argv = arguments;
-  var argc = argv.length;
-  var allDigits = /^\d$/;
-  var size = 0;
-  var highestIdx = 0;
-  var len = 0;
+  let i = 0
+  let pr = ''
+  const argv = arguments
+  const argc = argv.length
+  const allDigits = /^\d$/
+  let size = 0
+  let highestIdx = 0
+  let len = 0
 
   if (inputArr.hasOwnProperty('length')) {
     for (i = 1; i < argc; i++) {
-      inputArr[inputArr.length] = argv[i];
+      inputArr[inputArr.length] = argv[i]
     }
-    return inputArr.length;
+    return inputArr.length
   }
 
   // Associative (object)
   for (pr in inputArr) {
     if (inputArr.hasOwnProperty(pr)) {
-      ++len;
+      ++len
       if (pr.search(allDigits) !== -1) {
-        size = parseInt(pr, 10);
-        highestIdx = size > highestIdx ? size : highestIdx;
+        size = parseInt(pr, 10)
+        highestIdx = size > highestIdx ? size : highestIdx
       }
     }
   }
   for (i = 1; i < argc; i++) {
-    inputArr[++highestIdx] = argv[i];
+    inputArr[++highestIdx] = argv[i]
   }
 
-  return len + i - 1;
-};
-//# sourceMappingURL=array_push.js.map
+  return len + i - 1
+}

package/php/array/array_rand.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function array_rand(array, num) {
   //       discuss at: https://locutus.io/php/array_rand/
   //      original by: Waldo Malqui Silva (https://waldo.malqui.info)
@@ -9,27 +7,26 @@ module.exports = function array_rand(array, num) {
 
   // By using Object.keys we support both, arrays and objects
   // which phpjs wants to support
-  var keys = Object.keys(array);
+  const keys = Object.keys(array)
 
   if (typeof num === 'undefined' || num === null) {
-    num = 1;
+    num = 1
   } else {
-    num = +num;
+    num = +num
   }
 
   if (isNaN(num) || num < 1 || num > keys.length) {
-    return null;
+    return null
   }
 
   // shuffle the array of keys
-  for (var i = keys.length - 1; i > 0; i--) {
-    var j = Math.floor(Math.random() * (i + 1)); // 0 ≤ j ≤ i
+  for (let i = keys.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1)) // 0 ≤ j ≤ i
 
-    var tmp = keys[j];
-    keys[j] = keys[i];
-    keys[i] = tmp;
+    const tmp = keys[j]
+    keys[j] = keys[i]
+    keys[i] = tmp
   }
 
-  return num === 1 ? keys[0] : keys.slice(0, num);
-};
-//# sourceMappingURL=array_rand.js.map
+  return num === 1 ? keys[0] : keys.slice(0, num)
+}