locutus 2.0.32 → 2.0.34

package/php/strings/sscanf.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function sscanf(str, format) {
   //  discuss at: https://locutus.io/php/sscanf/
   // original by: Brett Zamir (https://brett-zamir.me)
@@ -12,12 +10,12 @@ module.exports = function sscanf(str, format) {
   //   example 3: sscanf("10--20", "%2$d--%1$d") // Must escape '$' in PHP, but not JS
   //   returns 3: [20, 10]
 
-  var retArr = [];
-  var _NWS = /\S/;
-  var args = arguments;
-  var digit = void 0;
+  const retArr = []
+  const _NWS = /\S/
+  const args = arguments
+  let digit
 
-  var _setExtraConversionSpecs = function _setExtraConversionSpecs(offset) {
+  const _setExtraConversionSpecs = function (offset) {
     // Since a mismatched character sets us off track from future
     // legitimate finds, we just scan
     // to the end for any other conversion specifications (besides a percent literal),
@@ -27,84 +25,89 @@ module.exports = function sscanf(str, format) {
     // Do not allow % in last char. class
     // var matches = format.match(/%[+-]?([ 0]|'.)?-?\d*(\.\d+)?[bcdeufFosxX]/g);
     // Do not allow % in last char. class:
-    var matches = format.slice(offset).match(/%[cdeEufgosxX]/g);
+    const matches = format.slice(offset).match(/%[cdeEufgosxX]/g)
     // b, F,G give errors in PHP, but 'g', though also disallowed, doesn't
     if (matches) {
-      var lgth = matches.length;
+      let lgth = matches.length
       while (lgth--) {
-        retArr.push(null);
+        retArr.push(null)
       }
     }
-    return _finish();
-  };
+    return _finish()
+  }
 
-  var _finish = function _finish() {
+  const _finish = function () {
     if (args.length === 2) {
-      return retArr;
+      return retArr
     }
-    for (var i = 0; i < retArr.length; ++i) {
-      args[i + 2].value = retArr[i];
+    let i = 0
+    for (; i < retArr.length; ++i) {
+      args[i + 2].value = retArr[i]
     }
-    return i;
-  };
+    return i
+  }
 
-  var _addNext = function _addNext(j, regex, cb) {
+  const _addNext = function (j, regex, cb) {
     if (assign) {
-      var remaining = str.slice(j);
-      var check = width ? remaining.substr(0, width) : remaining;
-      var match = regex.exec(check);
+      const remaining = str.slice(j)
+      const check = width ? remaining.substr(0, width) : remaining
+      const match = regex.exec(check)
       // @todo: Make this more readable
-      var key = digit !== undefined ? digit : retArr.length;
-      var testNull = retArr[key] = match ? cb ? cb.apply(null, match) : match[0] : null;
+      const key = digit !== undefined ? digit : retArr.length
+      const testNull = (retArr[key] = match ? (cb ? cb.apply(null, match) : match[0]) : null)
       if (testNull === null) {
-        throw new Error('No match in string');
+        throw new Error('No match in string')
       }
-      return j + match[0].length;
+      return j + match[0].length
     }
-    return j;
-  };
+    return j
+  }
 
   if (arguments.length < 2) {
-    throw new Error('Not enough arguments passed to sscanf');
+    throw new Error('Not enough arguments passed to sscanf')
   }
 
+  // These need to be in outer scope for _addNext closure
+  let width = 0
+  let assign = true
+
   // PROCESS
-  for (var i = 0, j = 0; i < format.length; i++) {
-    var width = 0;
-    var assign = true;
+  for (let i = 0, j = 0; i < format.length; i++) {
+    width = 0
+    assign = true
 
     if (format.charAt(i) === '%') {
       if (format.charAt(i + 1) === '%') {
         if (str.charAt(j) === '%') {
           // a matched percent literal
           // skip beyond duplicated percent
-          ++i;
-          ++j;
-          continue;
+          ++i
+          ++j
+          continue
         }
         // Format indicated a percent literal, but not actually present
-        return _setExtraConversionSpecs(i + 2);
+        return _setExtraConversionSpecs(i + 2)
       }
 
       // CHARACTER FOLLOWING PERCENT IS NOT A PERCENT
 
       // We need 'g' set to get lastIndex
-      var prePattern = /^(?:(\d+)\$)?(\*)?(\d*)([hlL]?)/g;
+      const prePattern = /^(?:(\d+)\$)?(\*)?(\d*)([hlL]?)/g
 
-      var preConvs = prePattern.exec(format.slice(i + 1));
+      const preConvs = prePattern.exec(format.slice(i + 1))
 
-      var tmpDigit = digit;
+      const tmpDigit = digit
       if (tmpDigit && preConvs[1] === undefined) {
-        var msg = 'All groups in sscanf() must be expressed as numeric if ';
-        msg += 'any have already been used';
-        throw new Error(msg);
+        let msg = 'All groups in sscanf() must be expressed as numeric if '
+        msg += 'any have already been used'
+        throw new Error(msg)
       }
-      digit = preConvs[1] ? parseInt(preConvs[1], 10) - 1 : undefined;
+      digit = preConvs[1] ? parseInt(preConvs[1], 10) - 1 : undefined
 
-      assign = !preConvs[2];
-      width = parseInt(preConvs[3], 10);
-      var sizeCode = preConvs[4];
-      i += prePattern.lastIndex;
+      assign = !preConvs[2]
+      width = parseInt(preConvs[3], 10)
+      const sizeCode = preConvs[4]
+      i += prePattern.lastIndex
 
       // @todo: Does PHP do anything with these? Seems not to matter
       if (sizeCode) {
@@ -117,9 +120,9 @@ module.exports = function sscanf(str, format) {
             // Treats subsequent as long int (for d,i,n), or unsigned long int (for o,u,x);
             //    or as double (for e,f,g) instead of float or wchar_t instead of char
             // Treats subsequent as long double (for e,f,g)
-            break;
+            break
           default:
-            throw new Error('Unexpected size specifier in sscanf()!');
+            throw new Error('Unexpected size specifier in sscanf()!')
         }
       }
       // PROCESS CHARACTER
@@ -133,55 +136,56 @@ module.exports = function sscanf(str, format) {
             // Not supported in PHP sscanf; the argument is treated as a float, and
             //  presented as a floating-point number (non-locale aware)
             // sscanf doesn't support locales, so no need for two (see %f)
-            break;
+            break
           case 'g':
             // Not supported in PHP sscanf; shorter of %e and %f
             // Irrelevant to input conversion
-            break;
+            break
           case 'G':
             // Not supported in PHP sscanf; shorter of %E and %f
             // Irrelevant to input conversion
-            break;
+            break
           case 'b':
             // Not supported in PHP sscanf; the argument is treated as an integer,
             // and presented as a binary number
             // Not supported - couldn't distinguish from other integers
-            break;
-          case 'i':
+            break
+          case 'i': {
             // Integer with base detection (Equivalent of 'd', but base 0 instead of 10)
-            var pattern = /([+-])?(?:(?:0x([\da-fA-F]+))|(?:0([0-7]+))|(\d+))/;
+            const pattern = /([+-])?(?:(?:0x([\da-fA-F]+))|(?:0([0-7]+))|(\d+))/
             j = _addNext(j, pattern, function (num, sign, hex, oct, dec) {
-              return hex ? parseInt(num, 16) : oct ? parseInt(num, 8) : parseInt(num, 10);
-            });
-            break;
+              return hex ? parseInt(num, 16) : oct ? parseInt(num, 8) : parseInt(num, 10)
+            })
+            break
+          }
           case 'n':
             // Number of characters processed so far
-            retArr[digit !== undefined ? digit : retArr.length - 1] = j;
-            break;
+            retArr[digit !== undefined ? digit : retArr.length - 1] = j
+            break
           // DOCUMENTED UNDER SPRINTF
           case 'c':
             // Get character; suppresses skipping over whitespace!
             // (but shouldn't be whitespace in format anyways, so no difference here)
             // Non-greedy match
-            j = _addNext(j, new RegExp('.{1,' + (width || 1) + '}'));
-            break;
+            j = _addNext(j, new RegExp('.{1,' + (width || 1) + '}'))
+            break
           case 'D':
           case 'd':
             // sscanf documented decimal number; equivalent of 'd';
             // Optionally signed decimal integer
             j = _addNext(j, /([+-])?(?:0*)(\d+)/, function (num, sign, dec) {
               // Ignores initial zeroes, unlike %i and parseInt()
-              var decInt = parseInt((sign || '') + dec, 10);
+              const decInt = parseInt((sign || '') + dec, 10)
               if (decInt < 0) {
                 // PHP also won't allow less than -2147483648
                 // integer overflow with negative
-                return decInt < -2147483648 ? -2147483648 : decInt;
+                return decInt < -2147483648 ? -2147483648 : decInt
               } else {
                 // PHP also won't allow greater than -2147483647
-                return decInt < 2147483647 ? decInt : 2147483647;
+                return decInt < 2147483647 ? decInt : 2147483647
               }
-            });
-            break;
+            })
+            break
           case 'f':
           case 'E':
           case 'e':
@@ -190,79 +194,78 @@ module.exports = function sscanf(str, format) {
             // These don't discriminate here as both allow exponential float of either case
             j = _addNext(j, /([+-])?(?:0*)(\d*\.?\d*(?:[eE]?\d+)?)/, function (num, sign, dec) {
               if (dec === '.') {
-                return null;
+                return null
               }
               // Ignores initial zeroes, unlike %i and parseFloat()
-              return parseFloat((sign || '') + dec);
-            });
-            break;
+              return parseFloat((sign || '') + dec)
+            })
+            break
           case 'u':
             // unsigned decimal integer
             // We won't deal with integer overflows due to signs
             j = _addNext(j, /([+-])?(?:0*)(\d+)/, function (num, sign, dec) {
               // Ignores initial zeroes, unlike %i and parseInt()
-              var decInt = parseInt(dec, 10);
+              const decInt = parseInt(dec, 10)
               if (sign === '-') {
                 // PHP also won't allow greater than 4294967295
                 // integer overflow with negative
-                return 4294967296 - decInt;
+                return 4294967296 - decInt
               } else {
-                return decInt < 4294967295 ? decInt : 4294967295;
+                return decInt < 4294967295 ? decInt : 4294967295
               }
-            });
-            break;
+            })
+            break
           case 'o':
             // Octal integer // @todo: add overflows as above?
             j = _addNext(j, /([+-])?(?:0([0-7]+))/, function (num, sign, oct) {
-              return parseInt(num, 8);
-            });
-            break;
+              return parseInt(num, 8)
+            })
+            break
           case 's':
             // Greedy match
-            j = _addNext(j, /\S+/);
-            break;
+            j = _addNext(j, /\S+/)
+            break
           case 'X':
           case 'x':
             // Same as 'x'?
             // @todo: add overflows as above?
             // Initial 0x not necessary here
             j = _addNext(j, /([+-])?(?:(?:0x)?([\da-fA-F]+))/, function (num, sign, hex) {
-              return parseInt(num, 16);
-            });
-            break;
+              return parseInt(num, 16)
+            })
+            break
           case '':
             // If no character left in expression
-            throw new Error('Missing character after percent mark in sscanf() format argument');
+            throw new Error('Missing character after percent mark in sscanf() format argument')
           default:
-            throw new Error('Unrecognized character after percent mark in sscanf() format argument');
+            throw new Error('Unrecognized character after percent mark in sscanf() format argument')
         }
       } catch (e) {
         if (e === 'No match in string') {
           // Allow us to exit
-          return _setExtraConversionSpecs(i + 2);
+          return _setExtraConversionSpecs(i + 2)
         }
         // Calculate skipping beyond initial percent too
       }
-      ++i;
+      ++i
     } else if (format.charAt(i) !== str.charAt(j)) {
       // @todo: Double-check i whitespace ignored in string and/or formats
-      _NWS.lastIndex = 0;
+      _NWS.lastIndex = 0
       if (_NWS.test(str.charAt(j)) || str.charAt(j) === '') {
         // Whitespace doesn't need to be an exact match)
-        return _setExtraConversionSpecs(i + 1);
+        return _setExtraConversionSpecs(i + 1)
       } else {
         // Adjust strings when encounter non-matching whitespace,
         // so they align in future checks above
         // Ok to replace with j++;?
-        str = str.slice(0, j) + str.slice(j + 1);
-        i--;
+        str = str.slice(0, j) + str.slice(j + 1)
+        i--
       }
     } else {
-      j++;
+      j++
     }
   }
 
   // POST-PROCESSING
-  return _finish();
-};
-//# sourceMappingURL=sscanf.js.map
+  return _finish()
+}

package/php/strings/str_getcsv.js

@@ -1,54 +1,59 @@
-'use strict';
-
+// biome-ignore lint/suspicious/noShadowRestrictedNames: escape is PHP parameter name
 module.exports = function str_getcsv(input, delimiter, enclosure, escape) {
-  //  discuss at: https://locutus.io/php/str_getcsv/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  //   example 1: str_getcsv('"abc","def","ghi"')
-  //   returns 1: ['abc', 'def', 'ghi']
-  //   example 2: str_getcsv('"row2""cell1","row2cell2","row2cell3"', null, null, '"')
-  //   returns 2: ['row2"cell1', 'row2cell2', 'row2cell3']
+  //      discuss at: https://locutus.io/php/str_getcsv/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //       example 1: str_getcsv('"abc","def","ghi"')
+  //       returns 1: ['abc', 'def', 'ghi']
+  //       example 2: str_getcsv('"row2""cell1","row2cell2","row2cell3"', null, null, '"')
+  //       returns 2: ['row2"cell1', 'row2cell2', 'row2cell3']
 
   /*
   // These test cases allowing for missing delimiters are not currently supported
     str_getcsv('"row2""cell1",row2cell2,row2cell3', null, null, '"');
     ['row2"cell1', 'row2cell2', 'row2cell3']
-     str_getcsv('row1cell1,"row1,cell2",row1cell3', null, null, '"');
+
+    str_getcsv('row1cell1,"row1,cell2",row1cell3', null, null, '"');
     ['row1cell1', 'row1,cell2', 'row1cell3']
-     str_getcsv('"row2""cell1",row2cell2,"row2""""cell3"');
+
+    str_getcsv('"row2""cell1",row2cell2,"row2""""cell3"');
     ['row2"cell1', 'row2cell2', 'row2""cell3']
-     str_getcsv('row1cell1,"row1,cell2","row1"",""cell3"', null, null, '"');
+
+    str_getcsv('row1cell1,"row1,cell2","row1"",""cell3"', null, null, '"');
     ['row1cell1', 'row1,cell2', 'row1","cell3'];
-     Should also test newlines within
+
+    Should also test newlines within
   */
 
-  var i = void 0;
-  var inpLen = void 0;
-  var output = [];
-  var _backwards = function _backwards(str) {
+  let i
+  let inpLen
+  const output = []
+  const _backwards = function (str) {
     // We need to go backwards to simulate negative look-behind (don't split on
     // an escaped enclosure even if followed by the delimiter and another enclosure mark)
-    return str.split('').reverse().join('');
-  };
-  var _pq = function _pq(str) {
+    return str.split('').reverse().join('')
+  }
+  const _pq = function (str) {
     // preg_quote()
-    return String(str).replace(/([\\.+*?[^\]$(){}=!<>|:])/g, '\\$1');
-  };
+    return String(str).replace(/([\\.+*?[^\]$(){}=!<>|:])/g, '\\$1')
+  }
 
-  delimiter = delimiter || ',';
-  enclosure = enclosure || '"';
-  escape = escape || '\\';
-  var pqEnc = _pq(enclosure);
-  var pqEsc = _pq(escape);
+  delimiter = delimiter || ','
+  enclosure = enclosure || '"'
+  escape = escape || '\\'
+  const pqEnc = _pq(enclosure)
+  const pqEsc = _pq(escape)
 
-  input = input.replace(new RegExp('^\\s*' + pqEnc), '').replace(new RegExp(pqEnc + '\\s*$'), '');
+  input = input.replace(new RegExp('^\\s*' + pqEnc), '').replace(new RegExp(pqEnc + '\\s*$'), '')
 
   // PHP behavior may differ by including whitespace even outside of the enclosure
-  input = _backwards(input).split(new RegExp(pqEnc + '\\s*' + _pq(delimiter) + '\\s*' + pqEnc + '(?!' + pqEsc + ')', 'g')).reverse();
+  input = _backwards(input)
+    .split(new RegExp(pqEnc + '\\s*' + _pq(delimiter) + '\\s*' + pqEnc + '(?!' + pqEsc + ')', 'g'))
+    .reverse()
 
   for (i = 0, inpLen = input.length; i < inpLen; i++) {
-    output.push(_backwards(input[i]).replace(new RegExp(pqEsc + pqEnc, 'g'), enclosure));
+    output.push(_backwards(input[i]).replace(new RegExp(pqEsc + pqEnc, 'g'), enclosure))
   }
 
-  return output;
-};
-//# sourceMappingURL=str_getcsv.js.map
+  return output
+}

package/php/strings/str_ireplace.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 str_ireplace(search, replace, subject, countObj) {
   //  discuss at: https://locutus.io/php/str_ireplace/
   // original by: Glen Arason (https://CanadianDomainRegistry.ca)
@@ -20,88 +16,87 @@ module.exports = function str_ireplace(search, replace, subject, countObj) {
   //   example 3: str_ireplace('', '.', 'aaa')
   //   returns 3: 'aaa'
 
-  var i = 0;
-  var j = 0;
-  var temp = '';
-  var repl = '';
-  var sl = 0;
-  var fl = 0;
-  var f = '';
-  var r = '';
-  var s = '';
-  var ra = '';
-  var otemp = '';
-  var oi = '';
-  var ofjl = '';
-  var os = subject;
-  var osa = Object.prototype.toString.call(os) === '[object Array]';
+  let i = 0
+  let j = 0
+  let temp = ''
+  let repl = ''
+  let sl = 0
+  let fl = 0
+  let f = ''
+  let r = ''
+  let s = ''
+  let ra = ''
+  let otemp = ''
+  let oi = ''
+  let ofjl = ''
+  let os = subject
+  const osa = Array.isArray(os)
   // var sa = ''
 
-  if ((typeof search === 'undefined' ? 'undefined' : _typeof(search)) === 'object') {
-    temp = search;
-    search = [];
+  if (typeof search === 'object') {
+    temp = search
+    search = []
     for (i = 0; i < temp.length; i += 1) {
-      search[i] = temp[i].toLowerCase();
+      search[i] = temp[i].toLowerCase()
     }
   } else {
-    search = search.toLowerCase();
+    search = search.toLowerCase()
   }
 
-  if ((typeof subject === 'undefined' ? 'undefined' : _typeof(subject)) === 'object') {
-    temp = subject;
-    subject = [];
+  if (typeof subject === 'object') {
+    temp = subject
+    subject = []
     for (i = 0; i < temp.length; i += 1) {
-      subject[i] = temp[i].toLowerCase();
+      subject[i] = temp[i].toLowerCase()
     }
   } else {
-    subject = subject.toLowerCase();
+    subject = subject.toLowerCase()
   }
 
-  if ((typeof search === 'undefined' ? 'undefined' : _typeof(search)) === 'object' && typeof replace === 'string') {
-    temp = replace;
-    replace = [];
+  if (typeof search === 'object' && typeof replace === 'string') {
+    temp = replace
+    replace = []
     for (i = 0; i < search.length; i += 1) {
-      replace[i] = temp;
+      replace[i] = temp
     }
   }
 
-  temp = '';
-  f = [].concat(search);
-  r = [].concat(replace);
-  ra = Object.prototype.toString.call(r) === '[object Array]';
-  s = subject;
-  // sa = Object.prototype.toString.call(s) === '[object Array]'
-  s = [].concat(s);
-  os = [].concat(os);
+  temp = ''
+  f = [].concat(search)
+  r = [].concat(replace)
+  ra = Array.isArray(r)
+  s = subject
+  // sa = Array.isArray(s)
+  s = [].concat(s)
+  os = [].concat(os)
 
   if (countObj) {
-    countObj.value = 0;
+    countObj.value = 0
   }
 
   for (i = 0, sl = s.length; i < sl; i++) {
     if (s[i] === '') {
-      continue;
+      continue
     }
     for (j = 0, fl = f.length; j < fl; j++) {
       if (f[j] === '') {
-        continue;
+        continue
       }
-      temp = s[i] + '';
-      repl = ra ? r[j] !== undefined ? r[j] : '' : r[0];
-      s[i] = temp.split(f[j]).join(repl);
-      otemp = os[i] + '';
-      oi = temp.indexOf(f[j]);
-      ofjl = f[j].length;
+      temp = s[i] + ''
+      repl = ra ? (r[j] !== undefined ? r[j] : '') : r[0]
+      s[i] = temp.split(f[j]).join(repl)
+      otemp = os[i] + ''
+      oi = temp.indexOf(f[j])
+      ofjl = f[j].length
       if (oi >= 0) {
-        os[i] = otemp.split(otemp.substr(oi, ofjl)).join(repl);
+        os[i] = otemp.split(otemp.substr(oi, ofjl)).join(repl)
       }
 
       if (countObj) {
-        countObj.value += temp.split(f[j]).length - 1;
+        countObj.value += temp.split(f[j]).length - 1
       }
     }
   }
 
-  return osa ? os : os[0];
-};
-//# sourceMappingURL=str_ireplace.js.map
+  return osa ? os : os[0]
+}

package/php/strings/str_pad.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function str_pad(input, padLength, padString, padType) {
   //  discuss at: https://locutus.io/php/str_pad/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -11,38 +9,37 @@ module.exports = function str_pad(input, padLength, padString, padType) {
   //   example 2: str_pad('Kevin van Zonneveld', 30, '-', 'STR_PAD_BOTH')
   //   returns 2: '------Kevin van Zonneveld-----'
 
-  var half = '';
-  var padToGo = void 0;
+  let half = ''
+  let padToGo
 
-  var _strPadRepeater = function _strPadRepeater(s, len) {
-    var collect = '';
+  const _strPadRepeater = function (s, len) {
+    let collect = ''
 
     while (collect.length < len) {
-      collect += s;
+      collect += s
     }
-    collect = collect.substr(0, len);
+    collect = collect.substr(0, len)
 
-    return collect;
-  };
+    return collect
+  }
 
-  input += '';
-  padString = padString !== undefined ? padString : ' ';
+  input += ''
+  padString = padString !== undefined ? padString : ' '
 
   if (padType !== 'STR_PAD_LEFT' && padType !== 'STR_PAD_RIGHT' && padType !== 'STR_PAD_BOTH') {
-    padType = 'STR_PAD_RIGHT';
+    padType = 'STR_PAD_RIGHT'
   }
   if ((padToGo = padLength - input.length) > 0) {
     if (padType === 'STR_PAD_LEFT') {
-      input = _strPadRepeater(padString, padToGo) + input;
+      input = _strPadRepeater(padString, padToGo) + input
     } else if (padType === 'STR_PAD_RIGHT') {
-      input = input + _strPadRepeater(padString, padToGo);
+      input = input + _strPadRepeater(padString, padToGo)
     } else if (padType === 'STR_PAD_BOTH') {
-      half = _strPadRepeater(padString, Math.ceil(padToGo / 2));
-      input = half + input + half;
-      input = input.substr(0, padLength);
+      half = _strPadRepeater(padString, Math.ceil(padToGo / 2))
+      input = half + input + half
+      input = input.substr(0, padLength)
     }
   }
 
-  return input;
-};
-//# sourceMappingURL=str_pad.js.map
+  return input
+}