locutus 2.0.32 → 2.0.35

package/php/strings/addcslashes.js

@@ -1,15 +1,14 @@
-'use strict';
-
 module.exports = function addcslashes(str, charlist) {
-  //  discuss at: https://locutus.io/php/addcslashes/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  //      note 1: We show double backslashes in the return value example
-  //      note 1: code below because a JavaScript string will not
-  //      note 1: render them as backslashes otherwise
-  //   example 1: addcslashes('foo[ ]', 'A..z'); // Escape all ASCII within capital A to lower z range, including square brackets
-  //   returns 1: "\\f\\o\\o\\[ \\]"
-  //   example 2: addcslashes("zoo['.']", 'z..A'); // Only escape z, period, and A here since not a lower-to-higher range
-  //   returns 2: "\\zoo['\\.']"
+  //      discuss at: https://locutus.io/php/addcslashes/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //          note 1: We show double backslashes in the return value example
+  //          note 1: code below because a JavaScript string will not
+  //          note 1: render them as backslashes otherwise
+  //       example 1: addcslashes('foo[ ]', 'A..z'); // Escape all ASCII within capital A to lower z range, including square brackets
+  //       returns 1: "\\f\\o\\o\\[ \\]"
+  //       example 2: addcslashes("zoo['.']", 'z..A'); // Only escape z, period, and A here since not a lower-to-higher range
+  //       returns 2: "\\zoo['\\.']"
   //   _example 3: addcslashes("@a\u0000\u0010\u00A9", "\0..\37!@\177..\377"); // Escape as octals those specified and less than 32 (0x20) or greater than 126 (0x7E), but not otherwise
   //   _returns 3: '\\@a\\000\\020\\302\\251'
   //   _example 4: addcslashes("\u0020\u007E", "\40..\175"); // Those between 32 (0x20 or 040) and 126 (0x7E or 0176) decimal value will be backslashed if specified (not octalized)
@@ -19,158 +18,157 @@ module.exports = function addcslashes(str, charlist) {
   //   _example 6: addcslashes("\r\u0007\n", '\0'); // Do not recognize C escape sequences if not specified
   //   _returns 6: "\r\u0007\n"
 
-  var target = '';
-  var chrs = [];
-  var i = 0;
-  var j = 0;
-  var c = '';
-  var next = '';
-  var rangeBegin = '';
-  var rangeEnd = '';
-  var chr = '';
-  var begin = 0;
-  var end = 0;
-  var octalLength = 0;
-  var postOctalPos = 0;
-  var cca = 0;
-  var escHexGrp = [];
-  var encoded = '';
-  var percentHex = /%([\dA-Fa-f]+)/g;
+  let target = ''
+  const chrs = []
+  let i = 0
+  let j = 0
+  let c = ''
+  let next = ''
+  let rangeBegin = ''
+  let rangeEnd = ''
+  let chr = ''
+  let begin = 0
+  let end = 0
+  let octalLength = 0
+  let postOctalPos = 0
+  let cca = 0
+  let escHexGrp = []
+  let encoded = ''
+  const percentHex = /%([\dA-Fa-f]+)/g
 
-  var _pad = function _pad(n, c) {
+  const _pad = function (n, c) {
     if ((n = n + '').length < c) {
-      return new Array(++c - n.length).join('0') + n;
+      return new Array(++c - n.length).join('0') + n
     }
-    return n;
-  };
+    return n
+  }
 
   for (i = 0; i < charlist.length; i++) {
-    c = charlist.charAt(i);
-    next = charlist.charAt(i + 1);
+    c = charlist.charAt(i)
+    next = charlist.charAt(i + 1)
     if (c === '\\' && next && /\d/.test(next)) {
       // Octal
-      rangeBegin = charlist.slice(i + 1).match(/^\d+/)[0];
-      octalLength = rangeBegin.length;
-      postOctalPos = i + octalLength + 1;
+      rangeBegin = charlist.slice(i + 1).match(/^\d+/)[0]
+      octalLength = rangeBegin.length
+      postOctalPos = i + octalLength + 1
       if (charlist.charAt(postOctalPos) + charlist.charAt(postOctalPos + 1) === '..') {
         // Octal begins range
-        begin = rangeBegin.charCodeAt(0);
+        begin = rangeBegin.charCodeAt(0)
         if (/\\\d/.test(charlist.charAt(postOctalPos + 2) + charlist.charAt(postOctalPos + 3))) {
           // Range ends with octal
-          rangeEnd = charlist.slice(postOctalPos + 3).match(/^\d+/)[0];
+          rangeEnd = charlist.slice(postOctalPos + 3).match(/^\d+/)[0]
           // Skip range end backslash
-          i += 1;
+          i += 1
         } else if (charlist.charAt(postOctalPos + 2)) {
           // Range ends with character
-          rangeEnd = charlist.charAt(postOctalPos + 2);
+          rangeEnd = charlist.charAt(postOctalPos + 2)
         } else {
-          throw new Error('Range with no end point');
+          throw new Error('Range with no end point')
         }
-        end = rangeEnd.charCodeAt(0);
+        end = rangeEnd.charCodeAt(0)
         if (end > begin) {
           // Treat as a range
           for (j = begin; j <= end; j++) {
-            chrs.push(String.fromCharCode(j));
+            chrs.push(String.fromCharCode(j))
           }
         } else {
           // Supposed to treat period, begin and end as individual characters only, not a range
-          chrs.push('.', rangeBegin, rangeEnd);
+          chrs.push('.', rangeBegin, rangeEnd)
         }
         // Skip dots and range end (already skipped range end backslash if present)
-        i += rangeEnd.length + 2;
+        i += rangeEnd.length + 2
       } else {
         // Octal is by itself
-        chr = String.fromCharCode(parseInt(rangeBegin, 8));
-        chrs.push(chr);
+        chr = String.fromCharCode(parseInt(rangeBegin, 8))
+        chrs.push(chr)
       }
       // Skip range begin
-      i += octalLength;
+      i += octalLength
     } else if (next + charlist.charAt(i + 2) === '..') {
       // Character begins range
-      rangeBegin = c;
-      begin = rangeBegin.charCodeAt(0);
+      rangeBegin = c
+      begin = rangeBegin.charCodeAt(0)
       if (/\\\d/.test(charlist.charAt(i + 3) + charlist.charAt(i + 4))) {
         // Range ends with octal
-        rangeEnd = charlist.slice(i + 4).match(/^\d+/)[0];
+        rangeEnd = charlist.slice(i + 4).match(/^\d+/)[0]
         // Skip range end backslash
-        i += 1;
+        i += 1
       } else if (charlist.charAt(i + 3)) {
         // Range ends with character
-        rangeEnd = charlist.charAt(i + 3);
+        rangeEnd = charlist.charAt(i + 3)
       } else {
-        throw new Error('Range with no end point');
+        throw new Error('Range with no end point')
       }
-      end = rangeEnd.charCodeAt(0);
+      end = rangeEnd.charCodeAt(0)
       if (end > begin) {
         // Treat as a range
         for (j = begin; j <= end; j++) {
-          chrs.push(String.fromCharCode(j));
+          chrs.push(String.fromCharCode(j))
         }
       } else {
         // Supposed to treat period, begin and end as individual characters only, not a range
-        chrs.push('.', rangeBegin, rangeEnd);
+        chrs.push('.', rangeBegin, rangeEnd)
       }
       // Skip dots and range end (already skipped range end backslash if present)
-      i += rangeEnd.length + 2;
+      i += rangeEnd.length + 2
     } else {
       // Character is by itself
-      chrs.push(c);
+      chrs.push(c)
     }
   }
 
   for (i = 0; i < str.length; i++) {
-    c = str.charAt(i);
+    c = str.charAt(i)
     if (chrs.indexOf(c) !== -1) {
-      target += '\\';
-      cca = c.charCodeAt(0);
+      target += '\\'
+      cca = c.charCodeAt(0)
       if (cca < 32 || cca > 126) {
         // Needs special escaping
         switch (c) {
           case '\n':
-            target += 'n';
-            break;
+            target += 'n'
+            break
           case '\t':
-            target += 't';
-            break;
-          case '\r':
-            target += 'r';
-            break;
-          case '\x07':
-            target += 'a';
-            break;
+            target += 't'
+            break
+          case '\u000D':
+            target += 'r'
+            break
+          case '\u0007':
+            target += 'a'
+            break
           case '\v':
-            target += 'v';
-            break;
+            target += 'v'
+            break
           case '\b':
-            target += 'b';
-            break;
+            target += 'b'
+            break
           case '\f':
-            target += 'f';
-            break;
+            target += 'f'
+            break
           default:
             // target += _pad(cca.toString(8), 3);break; // Sufficient for UTF-16
-            encoded = encodeURIComponent(c);
+            encoded = encodeURIComponent(c)
 
             // 3-length-padded UTF-8 octets
             if ((escHexGrp = percentHex.exec(encoded)) !== null) {
               // already added a slash above:
-              target += _pad(parseInt(escHexGrp[1], 16).toString(8), 3);
+              target += _pad(parseInt(escHexGrp[1], 16).toString(8), 3)
             }
             while ((escHexGrp = percentHex.exec(encoded)) !== null) {
-              target += '\\' + _pad(parseInt(escHexGrp[1], 16).toString(8), 3);
+              target += '\\' + _pad(parseInt(escHexGrp[1], 16).toString(8), 3)
             }
-            break;
+            break
         }
       } else {
         // Perform regular backslashed escaping
-        target += c;
+        target += c
       }
     } else {
       // Just add the character unescaped
-      target += c;
+      target += c
     }
   }
 
-  return target;
-};
-//# sourceMappingURL=addcslashes.js.map
+  return target
+}

package/php/strings/addslashes.js

@@ -1,18 +1,17 @@
-'use strict';
-
 module.exports = function addslashes(str) {
-  //  discuss at: https://locutus.io/php/addslashes/
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  // improved by: Ates Goral (https://magnetiq.com)
-  // improved by: marrtins
-  // improved by: Nate
-  // improved by: Onno Marsman (https://twitter.com/onnomarsman)
-  // improved by: Brett Zamir (https://brett-zamir.me)
-  // improved by: Oskar Larsson Högfeldt (https://oskar-lh.name/)
-  //    input by: Denny Wardhana
-  //   example 1: addslashes("kevin's birthday")
-  //   returns 1: "kevin\\'s birthday"
+  //      discuss at: https://locutus.io/php/addslashes/
+  // parity verified: PHP 8.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //     improved by: Ates Goral (https://magnetiq.com)
+  //     improved by: marrtins
+  //     improved by: Nate
+  //     improved by: Onno Marsman (https://twitter.com/onnomarsman)
+  //     improved by: Brett Zamir (https://brett-zamir.me)
+  //     improved by: Oskar Larsson Högfeldt (https://oskar-lh.name/)
+  //        input by: Denny Wardhana
+  //       example 1: addslashes("kevin's birthday")
+  //       returns 1: "kevin\\'s birthday"
 
-  return (str + '').replace(/[\\"']/g, '\\$&').replace(/\u0000/g, '\\0');
-};
-//# sourceMappingURL=addslashes.js.map
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: null byte escaping is intentional
+  return (str + '').replace(/[\\"']/g, '\\$&').replace(/\u0000/g, '\\0')
+}

package/php/strings/bin2hex.js

@@ -1,46 +1,22 @@
-'use strict';
-
 module.exports = function bin2hex(s) {
-  //  discuss at: https://locutus.io/php/bin2hex/
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
-  // bugfixed by: Linuxworld
-  // improved by: ntoniazzi (https://locutus.io/php/bin2hex:361#comment_177616)
-  //   example 1: bin2hex('Kev')
-  //   returns 1: '4b6576'
-  //   example 2: bin2hex(String.fromCharCode(0x00))
-  //   returns 2: '00'
-  //   example 3: bin2hex("æ")
-  //   returns 3: 'c3a6'
-
-  var encoder = new TextEncoder();
-  var bytes = encoder.encode(s);
-  var hex = '';
-  var _iteratorNormalCompletion = true;
-  var _didIteratorError = false;
-  var _iteratorError = undefined;
+  //      discuss at: https://locutus.io/php/bin2hex/
+  // parity verified: PHP 8.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //     bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
+  //     bugfixed by: Linuxworld
+  //     improved by: ntoniazzi (https://locutus.io/php/bin2hex:361#comment_177616)
+  //       example 1: bin2hex('Kev')
+  //       returns 1: '4b6576'
+  //       example 2: bin2hex(String.fromCharCode(0x00))
+  //       returns 2: '00'
+  //       example 3: bin2hex("æ")
+  //       returns 3: 'c3a6'
 
-  try {
-    for (var _iterator = bytes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var byte = _step.value;
-
-      hex += byte.toString(16).padStart(2, '0');
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
+  const encoder = new TextEncoder()
+  const bytes = encoder.encode(s)
+  let hex = ''
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, '0')
   }
-
-  return hex;
-};
-//# sourceMappingURL=bin2hex.js.map
+  return hex
+}

package/php/strings/chop.js

@@ -1,12 +1,10 @@
-'use strict';
-
 module.exports = function chop(str, charlist) {
-  //  discuss at: https://locutus.io/php/chop/
-  // original by: Paulo Freitas
-  //   example 1: chop('    Kevin van Zonneveld    ')
-  //   returns 1: '    Kevin van Zonneveld'
+  //      discuss at: https://locutus.io/php/chop/
+  // parity verified: PHP 8.3
+  //     original by: Paulo Freitas
+  //       example 1: chop('    Kevin van Zonneveld    ')
+  //       returns 1: '    Kevin van Zonneveld'
 
-  var rtrim = require('../strings/rtrim');
-  return rtrim(str, charlist);
-};
-//# sourceMappingURL=chop.js.map
+  const rtrim = require('../strings/rtrim')
+  return rtrim(str, charlist)
+}

package/php/strings/chr.js

@@ -1,22 +1,20 @@
-"use strict";
-
 module.exports = function chr(codePt) {
-  //  discuss at: https://locutus.io/php/chr/
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  // improved by: Brett Zamir (https://brett-zamir.me)
-  //   example 1: chr(75) === 'K'
-  //   example 1: chr(65536) === '\uD800\uDC00'
-  //   returns 1: true
-  //   returns 1: true
+  //      discuss at: https://locutus.io/php/chr/
+  // parity verified: PHP 8.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //     improved by: Brett Zamir (https://brett-zamir.me)
+  //          note 1: Unlike PHP (which wraps at 256), this implementation
+  //          note 1: supports Unicode code points beyond 255 using surrogates
+  //       example 1: chr(75) === 'K'
+  //       returns 1: true
 
   if (codePt > 0xffff) {
     // Create a four-byte string (length 2) since this code point is high
     //   enough for the UTF-16 encoding (JavaScript internal use), to
     //   require representation with two surrogates (reserved non-characters
     //   used for building other characters; the first is "high" and the next "low")
-    codePt -= 0x10000;
-    return String.fromCharCode(0xd800 + (codePt >> 10), 0xdc00 + (codePt & 0x3ff));
+    codePt -= 0x10000
+    return String.fromCharCode(0xd800 + (codePt >> 10), 0xdc00 + (codePt & 0x3ff))
   }
-  return String.fromCharCode(codePt);
-};
-//# sourceMappingURL=chr.js.map
+  return String.fromCharCode(codePt)
+}

package/php/strings/chunk_split.js

@@ -1,23 +1,21 @@
-'use strict';
-
 module.exports = function chunk_split(body, chunklen, end) {
-  //  discuss at: https://locutus.io/php/chunk_split/
-  // original by: Paulo Freitas
-  //    input by: Brett Zamir (https://brett-zamir.me)
-  // bugfixed by: Kevin van Zonneveld (https://kvz.io)
-  // improved by: Theriault (https://github.com/Theriault)
-  //   example 1: chunk_split('Hello world!', 1, '*')
-  //   returns 1: 'H*e*l*l*o* *w*o*r*l*d*!*'
-  //   example 2: chunk_split('Hello world!', 10, '*')
-  //   returns 2: 'Hello worl*d!*'
+  //      discuss at: https://locutus.io/php/chunk_split/
+  // parity verified: PHP 8.3
+  //     original by: Paulo Freitas
+  //        input by: Brett Zamir (https://brett-zamir.me)
+  //     bugfixed by: Kevin van Zonneveld (https://kvz.io)
+  //     improved by: Theriault (https://github.com/Theriault)
+  //       example 1: chunk_split('Hello world!', 1, '*')
+  //       returns 1: 'H*e*l*l*o* *w*o*r*l*d*!*'
+  //       example 2: chunk_split('Hello world!', 10, '*')
+  //       returns 2: 'Hello worl*d!*'
 
-  chunklen = parseInt(chunklen, 10) || 76;
-  end = end || '\r\n';
+  chunklen = parseInt(chunklen, 10) || 76
+  end = end || '\r\n'
 
   if (chunklen < 1) {
-    return false;
+    return false
   }
 
-  return body.match(new RegExp('.{0,' + chunklen + '}', 'g')).join(end);
-};
-//# sourceMappingURL=chunk_split.js.map
+  return body.match(new RegExp('.{0,' + chunklen + '}', 'g')).join(end)
+}