locutus 2.0.32 → 2.0.34

package/php/array/array_reduce.js

@@ -1,5 +1,3 @@
-"use strict";
-
 module.exports = function array_reduce(aInput, callback) {
   //  discuss at: https://locutus.io/php/array_reduce/
   // original by: Alfonso Jimenez (https://www.alfonsojimenez.com)
@@ -7,22 +5,21 @@ module.exports = function array_reduce(aInput, callback) {
   //   example 1: array_reduce([1, 2, 3, 4, 5], function (v, w){v += w;return v;})
   //   returns 1: 15
 
-  var lon = aInput.length;
-  var res = 0;
-  var i = 0;
-  var tmp = [];
+  const lon = aInput.length
+  let res = 0
+  let i = 0
+  let tmp = []
 
   for (i = 0; i < lon; i += 2) {
-    tmp[0] = aInput[i];
+    tmp[0] = aInput[i]
     if (aInput[i + 1]) {
-      tmp[1] = aInput[i + 1];
+      tmp[1] = aInput[i + 1]
     } else {
-      tmp[1] = 0;
+      tmp[1] = 0
     }
-    res += callback.apply(null, tmp);
-    tmp = [];
+    res += callback.apply(null, tmp)
+    tmp = []
   }
 
-  return res;
-};
-//# sourceMappingURL=array_reduce.js.map
+  return res
+}

package/php/array/array_replace.js

@@ -1,33 +1,30 @@
-'use strict';
-
 module.exports = function array_replace(arr) {
   //  discuss at: https://locutus.io/php/array_replace/
   // original by: Brett Zamir (https://brett-zamir.me)
   //   example 1: array_replace(["orange", "banana", "apple", "raspberry"], {0 : "pineapple", 4 : "cherry"}, {0:"grape"})
   //   returns 1: {0: 'grape', 1: 'banana', 2: 'apple', 3: 'raspberry', 4: 'cherry'}
 
-  var retObj = {};
-  var i = 0;
-  var p = '';
-  var argl = arguments.length;
+  const retObj = {}
+  let i = 0
+  let p = ''
+  const argl = arguments.length
 
   if (argl < 2) {
-    throw new Error('There should be at least 2 arguments passed to array_replace()');
+    throw new Error('There should be at least 2 arguments passed to array_replace()')
   }
 
   // Although docs state that the arguments are passed in by reference,
   // it seems they are not altered, but rather the copy that is returned
   // (just guessing), so we make a copy here, instead of acting on arr itself
   for (p in arr) {
-    retObj[p] = arr[p];
+    retObj[p] = arr[p]
   }
 
   for (i = 1; i < argl; i++) {
     for (p in arguments[i]) {
-      retObj[p] = arguments[i][p];
+      retObj[p] = arguments[i][p]
     }
   }
 
-  return retObj;
-};
-//# sourceMappingURL=array_replace.js.map
+  return retObj
+}

package/php/array/array_replace_recursive.js

@@ -1,47 +1,43 @@
-'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_replace_recursive(arr) {
-  //  discuss at: https://locutus.io/php/array_replace_recursive/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  //   example 1: array_replace_recursive({'citrus' : ['orange'], 'berries' : ['blackberry', 'raspberry']}, {'citrus' : ['pineapple'], 'berries' : ['blueberry']})
-  //   returns 1: {citrus : ['pineapple'], berries : ['blueberry', 'raspberry']}
+  //      discuss at: https://locutus.io/php/array_replace_recursive/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //       example 1: array_replace_recursive({'citrus' : ['orange'], 'berries' : ['blackberry', 'raspberry']}, {'citrus' : ['pineapple'], 'berries' : ['blueberry']})
+  //       returns 1: {citrus : ['pineapple'], berries : ['blueberry', 'raspberry']}
 
-  var i = 0;
-  var p = '';
-  var argl = arguments.length;
-  var retObj = void 0;
+  let i = 0
+  let p = ''
+  const argl = arguments.length
+  let retObj
 
   if (argl < 2) {
-    throw new Error('There should be at least 2 arguments passed to array_replace_recursive()');
+    throw new Error('There should be at least 2 arguments passed to array_replace_recursive()')
   }
 
   // Although docs state that the arguments are passed in by reference,
   // it seems they are not altered, but rather the copy that is returned
   // So we make a copy here, instead of acting on arr itself
-  if (Object.prototype.toString.call(arr) === '[object Array]') {
-    retObj = [];
+  if (Array.isArray(arr)) {
+    retObj = []
     for (p in arr) {
-      retObj.push(arr[p]);
+      retObj.push(arr[p])
     }
   } else {
-    retObj = {};
+    retObj = {}
     for (p in arr) {
-      retObj[p] = arr[p];
+      retObj[p] = arr[p]
     }
   }
 
   for (i = 1; i < argl; i++) {
     for (p in arguments[i]) {
-      if (retObj[p] && _typeof(retObj[p]) === 'object') {
-        retObj[p] = array_replace_recursive(retObj[p], arguments[i][p]);
+      if (retObj[p] && typeof retObj[p] === 'object') {
+        retObj[p] = array_replace_recursive(retObj[p], arguments[i][p])
       } else {
-        retObj[p] = arguments[i][p];
+        retObj[p] = arguments[i][p]
       }
     }
   }
 
-  return retObj;
-};
-//# sourceMappingURL=array_replace_recursive.js.map
+  return retObj
+}

package/php/array/array_reverse.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function array_reverse(array, preserveKeys) {
   //  discuss at: https://locutus.io/php/array_reverse/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -7,34 +5,33 @@ module.exports = function array_reverse(array, preserveKeys) {
   //   example 1: array_reverse( [ 'php', '4.0', ['green', 'red'] ], true)
   //   returns 1: { 2: ['green', 'red'], 1: '4.0', 0: 'php'}
 
-  var isArray = Object.prototype.toString.call(array) === '[object Array]';
-  var tmpArr = preserveKeys ? {} : [];
-  var key = void 0;
+  const isArray = Array.isArray(array)
+  const tmpArr = preserveKeys ? {} : []
+  let key
 
   if (isArray && !preserveKeys) {
-    return array.slice(0).reverse();
+    return array.slice(0).reverse()
   }
 
   if (preserveKeys) {
-    var keys = [];
+    const keys = []
     for (key in array) {
-      keys.push(key);
+      keys.push(key)
     }
 
-    var i = keys.length;
+    let i = keys.length
     while (i--) {
-      key = keys[i];
+      key = keys[i]
       // @todo: don't rely on browsers keeping keys in insertion order
       // it's implementation specific
       // eg. the result will differ from expected in Google Chrome
-      tmpArr[key] = array[key];
+      tmpArr[key] = array[key]
     }
   } else {
     for (key in array) {
-      tmpArr.unshift(array[key]);
+      tmpArr.unshift(array[key])
     }
   }
 
-  return tmpArr;
-};
-//# sourceMappingURL=array_reverse.js.map
+  return tmpArr
+}

package/php/array/array_search.js

@@ -1,50 +1,48 @@
-'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_search(needle, haystack, argStrict) {
-  //  discuss at: https://locutus.io/php/array_search/
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  //    input by: Brett Zamir (https://brett-zamir.me)
-  // bugfixed by: Kevin van Zonneveld (https://kvz.io)
-  // bugfixed by: Reynier de la Rosa (https://scriptinside.blogspot.com.es/)
-  //        test: skip-all
-  //   example 1: array_search('zonneveld', {firstname: 'kevin', middle: 'van', surname: 'zonneveld'})
-  //   returns 1: 'surname'
-  //   example 2: array_search('3', {a: 3, b: 5, c: 7})
-  //   returns 2: 'a'
+  //      discuss at: https://locutus.io/php/array_search/
+  // parity verified: PHP 8.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //        input by: Brett Zamir (https://brett-zamir.me)
+  //     bugfixed by: Kevin van Zonneveld (https://kvz.io)
+  //     bugfixed by: Reynier de la Rosa (https://scriptinside.blogspot.com.es/)
+  //       example 1: array_search('zonneveld', {firstname: 'kevin', middle: 'van', surname: 'zonneveld'})
+  //       returns 1: 'surname'
+  //       example 2: array_search('3', {a: 3, b: 5, c: 7})
+  //       returns 2: 'a'
 
-  var strict = !!argStrict;
-  var key = '';
+  const strict = !!argStrict
+  let key = ''
 
-  if ((typeof needle === 'undefined' ? 'undefined' : _typeof(needle)) === 'object' && needle.exec) {
+  if (typeof needle === 'object' && needle.exec) {
     // Duck-type for RegExp
     if (!strict) {
       // Let's consider case sensitive searches as strict
-      var flags = 'i' + (needle.global ? 'g' : '') + (needle.multiline ? 'm' : '') + (
-      // sticky is FF only
-      needle.sticky ? 'y' : '');
-      needle = new RegExp(needle.source, flags);
+      const flags =
+        'i' +
+        (needle.global ? 'g' : '') +
+        (needle.multiline ? 'm' : '') +
+        // sticky is FF only
+        (needle.sticky ? 'y' : '')
+      needle = new RegExp(needle.source, flags)
     }
     for (key in haystack) {
       if (haystack.hasOwnProperty(key)) {
         if (needle.test(haystack[key])) {
-          return key;
+          return key
         }
       }
     }
-    return false;
+    return false
   }
 
   for (key in haystack) {
     if (haystack.hasOwnProperty(key)) {
-      // eslint-disable-next-line eqeqeq
-      if (strict && haystack[key] === needle || !strict && haystack[key] == needle) {
-        return key;
+      // biome-ignore lint/suspicious/noDoubleEquals: non-strict comparison intended
+      if ((strict && haystack[key] === needle) || (!strict && haystack[key] == needle)) {
+        return key
       }
     }
   }
 
-  return false;
-};
-//# sourceMappingURL=array_search.js.map
+  return false
+}

package/php/array/array_shift.js

@@ -1,5 +1,3 @@
-"use strict";
-
 module.exports = function array_shift(inputArr) {
   //  discuss at: https://locutus.io/php/array_shift/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -9,10 +7,9 @@ module.exports = function array_shift(inputArr) {
   //   returns 1: 'Kevin'
 
   if (inputArr.length === 0) {
-    return null;
+    return null
   }
   if (inputArr.length > 0) {
-    return inputArr.shift();
+    return inputArr.shift()
   }
-};
-//# sourceMappingURL=array_shift.js.map
+}

package/php/array/array_slice.js

@@ -1,17 +1,16 @@
-'use strict';
-
 module.exports = function array_slice(arr, offst, lgth, preserveKeys) {
-  //  discuss at: https://locutus.io/php/array_slice/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  //    input by: Brett Zamir (https://brett-zamir.me)
-  // bugfixed by: Kevin van Zonneveld (https://kvz.io)
-  //      note 1: Relies on is_int because !isNaN accepts floats
-  //   example 1: array_slice(["a", "b", "c", "d", "e"], 2, -1)
-  //   returns 1: [ 'c', 'd' ]
-  //   example 2: array_slice(["a", "b", "c", "d", "e"], 2, -1, true)
-  //   returns 2: {2: 'c', 3: 'd'}
+  //      discuss at: https://locutus.io/php/array_slice/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //        input by: Brett Zamir (https://brett-zamir.me)
+  //     bugfixed by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Relies on is_int because !isNaN accepts floats
+  //       example 1: array_slice(["a", "b", "c", "d", "e"], 2, -1)
+  //       returns 1: [ 'c', 'd' ]
+  //       example 2: array_slice(["a", "b", "c", "d", "e"], 2, -1, true)
+  //       returns 2: {2: 'c', 3: 'd'}
 
-  var isInt = require('../var/is_int');
+  const isInt = require('../var/is_int')
 
   /*
     if ('callee' in arr && 'length' in arr) {
@@ -19,56 +18,55 @@ module.exports = function array_slice(arr, offst, lgth, preserveKeys) {
     }
   */
 
-  var key = '';
+  let key = ''
 
-  if (Object.prototype.toString.call(arr) !== '[object Array]' || preserveKeys && offst !== 0) {
+  if (!Array.isArray(arr) || (preserveKeys && offst !== 0)) {
     // Assoc. array as input or if required as output
-    var lgt = 0;
-    var newAssoc = {};
+    let lgt = 0
+    const newAssoc = {}
     for (key in arr) {
-      lgt += 1;
-      newAssoc[key] = arr[key];
+      lgt += 1
+      newAssoc[key] = arr[key]
     }
-    arr = newAssoc;
+    arr = newAssoc
 
-    offst = offst < 0 ? lgt + offst : offst;
-    lgth = lgth === undefined ? lgt : lgth < 0 ? lgt + lgth - offst : lgth;
+    offst = offst < 0 ? lgt + offst : offst
+    lgth = lgth === undefined ? lgt : lgth < 0 ? lgt + lgth - offst : lgth
 
-    var assoc = {};
-    var start = false;
-    var it = -1;
-    var arrlgth = 0;
-    var noPkIdx = 0;
+    const assoc = {}
+    let start = false
+    let it = -1
+    let arrlgth = 0
+    let noPkIdx = 0
 
     for (key in arr) {
-      ++it;
+      ++it
       if (arrlgth >= lgth) {
-        break;
+        break
       }
       if (it === offst) {
-        start = true;
+        start = true
       }
       if (!start) {
-        continue;
+        continue
       }
-      ++arrlgth;
+      ++arrlgth
       if (isInt(key) && !preserveKeys) {
-        assoc[noPkIdx++] = arr[key];
+        assoc[noPkIdx++] = arr[key]
       } else {
-        assoc[key] = arr[key];
+        assoc[key] = arr[key]
       }
     }
     // Make as array-like object (though length will not be dynamic)
     // assoc.length = arrlgth;
-    return assoc;
+    return assoc
   }
 
   if (lgth === undefined) {
-    return arr.slice(offst);
+    return arr.slice(offst)
   } else if (lgth >= 0) {
-    return arr.slice(offst, offst + lgth);
+    return arr.slice(offst, offst + lgth)
   } else {
-    return arr.slice(offst, lgth);
+    return arr.slice(offst, lgth)
   }
-};
-//# sourceMappingURL=array_slice.js.map
+}

package/php/array/array_splice.js

@@ -1,122 +1,117 @@
-'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_splice(arr, offst, lgth, replacement) {
-  //  discuss at: https://locutus.io/php/array_splice/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  //    input by: Theriault (https://github.com/Theriault)
-  //      note 1: Order does get shifted in associative array input with numeric indices,
-  //      note 1: since PHP behavior doesn't preserve keys, but I understand order is
-  //      note 1: not reliable anyways
-  //      note 1: Note also that IE retains information about property position even
-  //      note 1: after being supposedly deleted, so use of this function may produce
-  //      note 1: unexpected results in IE if you later attempt to add back properties
-  //      note 1: with the same keys that had been deleted
-  //   example 1: var $input = {4: "red", 'abc': "green", 2: "blue", 'dud': "yellow"}
-  //   example 1: array_splice($input, 2)
-  //   returns 1: {4: "red", 'abc': "green"}
-  //   example 2: var $input = ["red", "green", "blue", "yellow"]
-  //   example 2: array_splice($input, 3, 0, "purple")
-  //   returns 2: []
-  //   example 3: var $input = ["red", "green", "blue", "yellow"]
-  //   example 3: array_splice($input, -1, 1, ["black", "maroon"])
-  //   returns 3: ["yellow"]
-  //        test: skip-1
+  //      discuss at: https://locutus.io/php/array_splice/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //        input by: Theriault (https://github.com/Theriault)
+  //          note 1: Order does get shifted in associative array input with numeric indices,
+  //          note 1: since PHP behavior doesn't preserve keys, but I understand order is
+  //          note 1: not reliable anyways
+  //          note 1: Note also that IE retains information about property position even
+  //          note 1: after being supposedly deleted, so use of this function may produce
+  //          note 1: unexpected results in IE if you later attempt to add back properties
+  //          note 1: with the same keys that had been deleted
+  //       example 1: var $input = ["red", "green", "blue", "yellow"]
+  //       example 1: array_splice($input, 2)
+  //       returns 1: ["blue", "yellow"]
+  //       example 2: var $input = ["red", "green", "blue", "yellow"]
+  //       example 2: array_splice($input, 3, 0, "purple")
+  //       returns 2: []
+  //       example 3: var $input = ["red", "green", "blue", "yellow"]
+  //       example 3: array_splice($input, -1, 1, ["black", "maroon"])
+  //       returns 3: ["yellow"]
 
-  var isInt = require('../var/is_int');
+  const isInt = require('../var/is_int')
 
-  var _checkToUpIndices = function _checkToUpIndices(arr, ct, key) {
+  const _checkToUpIndices = function (arr, ct, key) {
     // Deal with situation, e.g., if encounter index 4 and try
     // to set it to 0, but 0 exists later in loop (need to
     // increment all subsequent (skipping current key,
     // since we need its value below) until find unused)
     if (arr[ct] !== undefined) {
-      var tmp = ct;
-      ct += 1;
+      const tmp = ct
+      ct += 1
       if (ct === key) {
-        ct += 1;
+        ct += 1
       }
-      ct = _checkToUpIndices(arr, ct, key);
-      arr[ct] = arr[tmp];
-      delete arr[tmp];
+      ct = _checkToUpIndices(arr, ct, key)
+      arr[ct] = arr[tmp]
+      delete arr[tmp]
     }
-    return ct;
-  };
+    return ct
+  }
 
-  if (replacement && (typeof replacement === 'undefined' ? 'undefined' : _typeof(replacement)) !== 'object') {
-    replacement = [replacement];
+  if (replacement && typeof replacement !== 'object') {
+    replacement = [replacement]
   }
   if (lgth === undefined) {
-    lgth = offst >= 0 ? arr.length - offst : -offst;
+    lgth = offst >= 0 ? arr.length - offst : -offst
   } else if (lgth < 0) {
-    lgth = (offst >= 0 ? arr.length - offst : -offst) + lgth;
+    lgth = (offst >= 0 ? arr.length - offst : -offst) + lgth
   }
 
-  if (Object.prototype.toString.call(arr) !== '[object Array]') {
+  if (!Array.isArray(arr)) {
     /* if (arr.length !== undefined) {
      // Deal with array-like objects as input
     delete arr.length;
     } */
-    var lgt = 0;
-    var ct = -1;
-    var rmvd = [];
-    var rmvdObj = {};
-    var replCt = -1;
-    var intCt = -1;
-    var returnArr = true;
-    var rmvdCt = 0;
+    let lgt = 0
+    let ct = -1
+    const rmvd = []
+    const rmvdObj = {}
+    let replCt = -1
+    let intCt = -1
+    let returnArr = true
+    let rmvdCt = 0
     // var rmvdLngth = 0
-    var key = '';
+    let key = ''
     // rmvdObj.length = 0;
     for (key in arr) {
       // Can do arr.__count__ in some browsers
-      lgt += 1;
+      lgt += 1
     }
-    offst = offst >= 0 ? offst : lgt + offst;
+    offst = offst >= 0 ? offst : lgt + offst
     for (key in arr) {
-      ct += 1;
+      ct += 1
       if (ct < offst) {
         if (isInt(key)) {
-          intCt += 1;
+          intCt += 1
           if (parseInt(key, 10) === intCt) {
             // Key is already numbered ok, so don't need to change key for value
-            continue;
+            continue
           }
           // Deal with situation, e.g.,
-          _checkToUpIndices(arr, intCt, key);
+          _checkToUpIndices(arr, intCt, key)
           // if encounter index 4 and try to set it to 0, but 0 exists later in loop
-          arr[intCt] = arr[key];
-          delete arr[key];
+          arr[intCt] = arr[key]
+          delete arr[key]
         }
-        continue;
+        continue
       }
       if (returnArr && isInt(key)) {
-        rmvd.push(arr[key]);
+        rmvd.push(arr[key])
         // PHP starts over here too
-        rmvdObj[rmvdCt++] = arr[key];
+        rmvdObj[rmvdCt++] = arr[key]
       } else {
-        rmvdObj[key] = arr[key];
-        returnArr = false;
+        rmvdObj[key] = arr[key]
+        returnArr = false
       }
       // rmvdLngth += 1
       // rmvdObj.length += 1;
       if (replacement && replacement[++replCt]) {
-        arr[key] = replacement[replCt];
+        arr[key] = replacement[replCt]
       } else {
-        delete arr[key];
+        delete arr[key]
       }
     }
     // Make (back) into an array-like object
     // arr.length = lgt - rmvdLngth + (replacement ? replacement.length : 0);
-    return returnArr ? rmvd : rmvdObj;
+    return returnArr ? rmvd : rmvdObj
   }
 
   if (replacement) {
-    replacement.unshift(offst, lgth);
-    return Array.prototype.splice.apply(arr, replacement);
+    replacement.unshift(offst, lgth)
+    return Array.prototype.splice.apply(arr, replacement)
   }
 
-  return arr.splice(offst, lgth);
-};
-//# sourceMappingURL=array_splice.js.map
+  return arr.splice(offst, lgth)
+}

package/php/array/array_sum.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_sum(array) {
   //  discuss at: https://locutus.io/php/array_sum/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -17,20 +13,19 @@ module.exports = function array_sum(array) {
   //   example 2: array_sum($total)
   //   returns 2: 67.2
 
-  var key = void 0;
-  var sum = 0;
+  let key
+  let sum = 0
 
   // input sanitation
-  if ((typeof array === 'undefined' ? 'undefined' : _typeof(array)) !== 'object') {
-    return null;
+  if (typeof array !== 'object') {
+    return null
   }
 
   for (key in array) {
     if (!isNaN(parseFloat(array[key]))) {
-      sum += parseFloat(array[key]);
+      sum += parseFloat(array[key])
     }
   }
 
-  return sum;
-};
-//# sourceMappingURL=array_sum.js.map
+  return sum
+}