locutus 2.0.32 → 2.0.35

package/php/xdiff/xdiff_string_patch.js

@@ -1,16 +1,15 @@
-'use strict';
-
 module.exports = function xdiff_string_patch(originalStr, patch, flags, errorObj) {
-  //  discuss at: https://locutus.io/php/xdiff_string_patch/
-  // original by: Brett Zamir (https://brett-zamir.me)
-  // improved by: Steven Levithan (stevenlevithan.com)
-  //      note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
-  //      note 1: currently supported.
-  //      note 2: This has not been tested exhaustively yet.
-  //      note 3: The errorObj parameter (optional) if used must be passed in as a
-  //      note 3: object. The errors will then be written by reference into it's `value` property
-  //   example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
-  //   returns 1: 'Hello world!'
+  //      discuss at: https://locutus.io/php/xdiff_string_patch/
+  // parity verified: PHP 8.3
+  //     original by: Brett Zamir (https://brett-zamir.me)
+  //     improved by: Steven Levithan (stevenlevithan.com)
+  //          note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
+  //          note 1: currently supported.
+  //          note 2: This has not been tested exhaustively yet.
+  //          note 3: The errorObj parameter (optional) if used must be passed in as a
+  //          note 3: object. The errors will then be written by reference into it's `value` property
+  //       example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
+  //       returns 1: 'Hello world!'
 
   // First two functions were adapted from Steven Levithan, also under an MIT license
   // Adapted from XRegExp 1.5.0
@@ -18,184 +17,190 @@ module.exports = function xdiff_string_patch(originalStr, patch, flags, errorObj
   // MIT License
   // <https://xregexp.com>
 
-  var _getNativeFlags = function _getNativeFlags(regex) {
+  const _getNativeFlags = function (regex) {
     // Proposed for ES4; included in AS3
-    return [regex.global ? 'g' : '', regex.ignoreCase ? 'i' : '', regex.multiline ? 'm' : '', regex.extended ? 'x' : '', regex.sticky ? 'y' : ''].join('');
-  };
+    return [
+      regex.global ? 'g' : '',
+      regex.ignoreCase ? 'i' : '',
+      regex.multiline ? 'm' : '',
+      regex.extended ? 'x' : '',
+      regex.sticky ? 'y' : '',
+    ].join('')
+  }
 
-  var _cbSplit = function _cbSplit(string, sep) {
+  const _cbSplit = function (string, sep) {
     // If separator `s` is not a regex, use the native `split`
     if (!(sep instanceof RegExp)) {
       // Had problems to get it to work here using prototype test
-      return String.prototype.split.apply(string, arguments);
+      return String.prototype.split.apply(string, arguments)
     }
-    var str = String(string);
-    var output = [];
-    var lastLastIndex = 0;
-    var match = void 0;
-    var lastLength = void 0;
-    var limit = Infinity;
-    var x = sep._xregexp;
+    const str = String(string)
+    const output = []
+    let lastLastIndex = 0
+    let match
+    let lastLength
+    const limit = Infinity
+    const x = sep._xregexp
     // This is required if not `s.global`, and it avoids needing to set `s.lastIndex` to zero
     // and restore it to its original value when we're done using the regex
     // Brett paring down
-    var s = new RegExp(sep.source, _getNativeFlags(sep) + 'g');
+    const s = new RegExp(sep.source, _getNativeFlags(sep) + 'g')
     if (x) {
       s._xregexp = {
         source: x.source,
-        captureNames: x.captureNames ? x.captureNames.slice(0) : null
-      };
+        captureNames: x.captureNames ? x.captureNames.slice(0) : null,
+      }
     }
 
-    while (match = s.exec(str)) {
+    while ((match = s.exec(str))) {
       // Run the altered `exec` (required for `lastIndex` fix, etc.)
       if (s.lastIndex > lastLastIndex) {
-        output.push(str.slice(lastLastIndex, match.index));
+        output.push(str.slice(lastLastIndex, match.index))
 
         if (match.length > 1 && match.index < str.length) {
-          Array.prototype.push.apply(output, match.slice(1));
+          Array.prototype.push.apply(output, match.slice(1))
         }
 
-        lastLength = match[0].length;
-        lastLastIndex = s.lastIndex;
+        lastLength = match[0].length
+        lastLastIndex = s.lastIndex
 
         if (output.length >= limit) {
-          break;
+          break
         }
       }
 
       if (s.lastIndex === match.index) {
-        s.lastIndex++;
+        s.lastIndex++
       }
     }
 
     if (lastLastIndex === str.length) {
       if (!s.test('') || lastLength) {
-        output.push('');
+        output.push('')
       }
     } else {
-      output.push(str.slice(lastLastIndex));
+      output.push(str.slice(lastLastIndex))
     }
 
-    return output.length > limit ? output.slice(0, limit) : output;
-  };
-
-  var i = 0;
-  var ll = 0;
-  var ranges = [];
-  var lastLinePos = 0;
-  var firstChar = '';
-  var rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/;
-  var lineBreaks = /\r?\n/;
-  var lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks);
-  var origLines = _cbSplit(originalStr, lineBreaks);
-  var newStrArr = [];
-  var linePos = 0;
-  var errors = '';
-  var optTemp = 0; // Both string & integer (constant) input is allowed
-  var OPTS = {
+    return output.length > limit ? output.slice(0, limit) : output
+  }
+
+  let i = 0
+  let ll = 0
+  let ranges = []
+  let lastLinePos = 0
+  let firstChar = ''
+  const rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/
+  const lineBreaks = /\r?\n/
+  const lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks)
+  const origLines = _cbSplit(originalStr, lineBreaks)
+  const newStrArr = []
+  let linePos = 0
+  const errors = ''
+  let optTemp = 0 // Both string & integer (constant) input is allowed
+  const OPTS = {
     // Unsure of actual PHP values, so better to rely on string
     XDIFF_PATCH_NORMAL: 1,
     XDIFF_PATCH_REVERSE: 2,
-    XDIFF_PATCH_IGNORESPACE: 4
+    XDIFF_PATCH_IGNORESPACE: 4,
+  }
 
-    // Input defaulting & sanitation
-  };if (typeof originalStr !== 'string' || !patch) {
-    return false;
+  // Input defaulting & sanitation
+  if (typeof originalStr !== 'string' || !patch) {
+    return false
   }
   if (!flags) {
-    flags = 'XDIFF_PATCH_NORMAL';
+    flags = 'XDIFF_PATCH_NORMAL'
   }
 
   if (typeof flags !== 'number') {
     // Allow for a single string or an array of string flags
-    flags = [].concat(flags);
+    flags = [].concat(flags)
     for (i = 0; i < flags.length; i++) {
       // Resolve string input to bitwise e.g. 'XDIFF_PATCH_NORMAL' becomes 1
       if (OPTS[flags[i]]) {
-        optTemp = optTemp | OPTS[flags[i]];
+        optTemp = optTemp | OPTS[flags[i]]
       }
     }
-    flags = optTemp;
+    flags = optTemp
   }
 
   if (flags & OPTS.XDIFF_PATCH_NORMAL) {
     for (i = 0, ll = lines.length; i < ll; i++) {
-      ranges = lines[i].match(rangeExp);
+      ranges = lines[i].match(rangeExp)
       if (ranges) {
-        lastLinePos = linePos;
-        linePos = ranges[1] - 1;
+        lastLinePos = linePos
+        linePos = ranges[1] - 1
         while (lastLinePos < linePos) {
-          newStrArr[newStrArr.length] = origLines[lastLinePos++];
+          newStrArr[newStrArr.length] = origLines[lastLinePos++]
         }
         while (lines[++i] && rangeExp.exec(lines[i]) === null) {
-          firstChar = lines[i].charAt(0);
+          firstChar = lines[i].charAt(0)
           switch (firstChar) {
             case '-':
               // Skip including that line
-              ++linePos;
-              break;
+              ++linePos
+              break
             case '+':
-              newStrArr[newStrArr.length] = lines[i].slice(1);
-              break;
+              newStrArr[newStrArr.length] = lines[i].slice(1)
+              break
             case ' ':
-              newStrArr[newStrArr.length] = origLines[linePos++];
-              break;
+              newStrArr[newStrArr.length] = origLines[linePos++]
+              break
             default:
               // Reconcile with returning errrors arg?
-              throw new Error('Unrecognized initial character in unidiff line');
+              throw new Error('Unrecognized initial character in unidiff line')
           }
         }
         if (lines[i]) {
-          i--;
+          i--
         }
       }
     }
     while (linePos > 0 && linePos < origLines.length) {
-      newStrArr[newStrArr.length] = origLines[linePos++];
+      newStrArr[newStrArr.length] = origLines[linePos++]
     }
   } else if (flags & OPTS.XDIFF_PATCH_REVERSE) {
     // Only differs from above by a few lines
     for (i = 0, ll = lines.length; i < ll; i++) {
-      ranges = lines[i].match(rangeExp);
+      ranges = lines[i].match(rangeExp)
       if (ranges) {
-        lastLinePos = linePos;
-        linePos = ranges[3] - 1;
+        lastLinePos = linePos
+        linePos = ranges[3] - 1
         while (lastLinePos < linePos) {
-          newStrArr[newStrArr.length] = origLines[lastLinePos++];
+          newStrArr[newStrArr.length] = origLines[lastLinePos++]
         }
         while (lines[++i] && rangeExp.exec(lines[i]) === null) {
-          firstChar = lines[i].charAt(0);
+          firstChar = lines[i].charAt(0)
           switch (firstChar) {
             case '-':
-              newStrArr[newStrArr.length] = lines[i].slice(1);
-              break;
+              newStrArr[newStrArr.length] = lines[i].slice(1)
+              break
             case '+':
               // Skip including that line
-              ++linePos;
-              break;
+              ++linePos
+              break
             case ' ':
-              newStrArr[newStrArr.length] = origLines[linePos++];
-              break;
+              newStrArr[newStrArr.length] = origLines[linePos++]
+              break
             default:
               // Reconcile with returning errrors arg?
-              throw new Error('Unrecognized initial character in unidiff line');
+              throw new Error('Unrecognized initial character in unidiff line')
           }
         }
         if (lines[i]) {
-          i--;
+          i--
         }
       }
     }
     while (linePos > 0 && linePos < origLines.length) {
-      newStrArr[newStrArr.length] = origLines[linePos++];
+      newStrArr[newStrArr.length] = origLines[linePos++]
     }
   }
 
   if (errorObj) {
-    errorObj.value = errors;
+    errorObj.value = errors
   }
 
-  return newStrArr.join('\n');
-};
-//# sourceMappingURL=xdiff_string_patch.js.map
+  return newStrArr.join('\n')
+}

package/php/xml/index.js

@@ -1,5 +1,2 @@
-'use strict';
-
-module.exports.utf8_decode = require('./utf8_decode');
-module.exports.utf8_encode = require('./utf8_encode');
-//# sourceMappingURL=index.js.map
+module.exports.utf8_decode = require('./utf8_decode')
+module.exports.utf8_encode = require('./utf8_encode')

package/php/xml/utf8_decode.js

@@ -1,61 +1,59 @@
-'use strict';
-
 module.exports = function utf8_decode(strData) {
-  //  discuss at: https://locutus.io/php/utf8_decode/
-  // original by: Webtoolkit.info (https://www.webtoolkit.info/)
-  //    input by: Aman Gupta
-  //    input by: Brett Zamir (https://brett-zamir.me)
-  // improved by: Kevin van Zonneveld (https://kvz.io)
-  // improved by: Norman "zEh" Fuchs
-  // bugfixed by: hitwork
-  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
-  // bugfixed by: Kevin van Zonneveld (https://kvz.io)
-  // bugfixed by: kirilloid
-  // bugfixed by: w35l3y (https://www.wesley.eti.br)
-  //   example 1: utf8_decode('Kevin van Zonneveld')
-  //   returns 1: 'Kevin van Zonneveld'
-
-  var tmpArr = [];
-  var i = 0;
-  var c1 = 0;
-  var seqlen = 0;
-
-  strData += '';
+  //      discuss at: https://locutus.io/php/utf8_decode/
+  // parity verified: PHP 8.3
+  //     original by: Webtoolkit.info (https://www.webtoolkit.info/)
+  //        input by: Aman Gupta
+  //        input by: Brett Zamir (https://brett-zamir.me)
+  //     improved by: Kevin van Zonneveld (https://kvz.io)
+  //     improved by: Norman "zEh" Fuchs
+  //     bugfixed by: hitwork
+  //     bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
+  //     bugfixed by: Kevin van Zonneveld (https://kvz.io)
+  //     bugfixed by: kirilloid
+  //     bugfixed by: w35l3y (https://www.wesley.eti.br)
+  //       example 1: utf8_decode('Kevin van Zonneveld')
+  //       returns 1: 'Kevin van Zonneveld'
+
+  const tmpArr = []
+  let i = 0
+  let c1 = 0
+  let seqlen = 0
+
+  strData += ''
 
   while (i < strData.length) {
-    c1 = strData.charCodeAt(i) & 0xff;
-    seqlen = 0;
+    c1 = strData.charCodeAt(i) & 0xff
+    seqlen = 0
 
     // https://en.wikipedia.org/wiki/UTF-8#Codepage_layout
     if (c1 <= 0xbf) {
-      c1 = c1 & 0x7f;
-      seqlen = 1;
+      c1 = c1 & 0x7f
+      seqlen = 1
     } else if (c1 <= 0xdf) {
-      c1 = c1 & 0x1f;
-      seqlen = 2;
+      c1 = c1 & 0x1f
+      seqlen = 2
     } else if (c1 <= 0xef) {
-      c1 = c1 & 0x0f;
-      seqlen = 3;
+      c1 = c1 & 0x0f
+      seqlen = 3
     } else {
-      c1 = c1 & 0x07;
-      seqlen = 4;
+      c1 = c1 & 0x07
+      seqlen = 4
     }
 
-    for (var ai = 1; ai < seqlen; ++ai) {
-      c1 = c1 << 0x06 | strData.charCodeAt(ai + i) & 0x3f;
+    for (let ai = 1; ai < seqlen; ++ai) {
+      c1 = (c1 << 0x06) | (strData.charCodeAt(ai + i) & 0x3f)
     }
 
     if (seqlen === 4) {
-      c1 -= 0x10000;
-      tmpArr.push(String.fromCharCode(0xd800 | c1 >> 10 & 0x3ff));
-      tmpArr.push(String.fromCharCode(0xdc00 | c1 & 0x3ff));
+      c1 -= 0x10000
+      tmpArr.push(String.fromCharCode(0xd800 | ((c1 >> 10) & 0x3ff)))
+      tmpArr.push(String.fromCharCode(0xdc00 | (c1 & 0x3ff)))
     } else {
-      tmpArr.push(String.fromCharCode(c1));
+      tmpArr.push(String.fromCharCode(c1))
     }
 
-    i += seqlen;
+    i += seqlen
   }
 
-  return tmpArr.join('');
-};
-//# sourceMappingURL=utf8_decode.js.map
+  return tmpArr.join('')
+}

package/php/xml/utf8_encode.js

@@ -1,69 +1,67 @@
-'use strict';
-
 module.exports = function utf8_encode(argString) {
-  //  discuss at: https://locutus.io/php/utf8_encode/
-  // original by: Webtoolkit.info (https://www.webtoolkit.info/)
-  // improved by: Kevin van Zonneveld (https://kvz.io)
-  // improved by: sowberry
-  // improved by: Jack
-  // improved by: Yves Sucaet
-  // improved by: kirilloid
-  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
-  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
-  // bugfixed by: Ulrich
-  // bugfixed by: Rafał Kukawski (https://blog.kukawski.pl)
-  // bugfixed by: kirilloid
-  //   example 1: utf8_encode('Kevin van Zonneveld')
-  //   returns 1: 'Kevin van Zonneveld'
+  //      discuss at: https://locutus.io/php/utf8_encode/
+  // parity verified: PHP 8.3
+  //     original by: Webtoolkit.info (https://www.webtoolkit.info/)
+  //     improved by: Kevin van Zonneveld (https://kvz.io)
+  //     improved by: sowberry
+  //     improved by: Jack
+  //     improved by: Yves Sucaet
+  //     improved by: kirilloid
+  //     bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
+  //     bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
+  //     bugfixed by: Ulrich
+  //     bugfixed by: Rafał Kukawski (https://blog.kukawski.pl)
+  //     bugfixed by: kirilloid
+  //       example 1: utf8_encode('Kevin van Zonneveld')
+  //       returns 1: 'Kevin van Zonneveld'
 
   if (argString === null || typeof argString === 'undefined') {
-    return '';
+    return ''
   }
 
   // .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  var string = argString + '';
-  var utftext = '';
-  var start = void 0;
-  var end = void 0;
-  var stringl = 0;
+  const string = argString + ''
+  let utftext = ''
+  let start
+  let end
+  let stringl = 0
 
-  start = end = 0;
-  stringl = string.length;
-  for (var n = 0; n < stringl; n++) {
-    var c1 = string.charCodeAt(n);
-    var enc = null;
+  start = end = 0
+  stringl = string.length
+  for (let n = 0; n < stringl; n++) {
+    let c1 = string.charCodeAt(n)
+    let enc = null
 
     if (c1 < 128) {
-      end++;
+      end++
     } else if (c1 > 127 && c1 < 2048) {
-      enc = String.fromCharCode(c1 >> 6 | 192, c1 & 63 | 128);
+      enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128)
     } else if ((c1 & 0xf800) !== 0xd800) {
-      enc = String.fromCharCode(c1 >> 12 | 224, c1 >> 6 & 63 | 128, c1 & 63 | 128);
+      enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128)
     } else {
       // surrogate pairs
       if ((c1 & 0xfc00) !== 0xd800) {
-        throw new RangeError('Unmatched trail surrogate at ' + n);
+        throw new RangeError('Unmatched trail surrogate at ' + n)
       }
-      var c2 = string.charCodeAt(++n);
+      const c2 = string.charCodeAt(++n)
       if ((c2 & 0xfc00) !== 0xdc00) {
-        throw new RangeError('Unmatched lead surrogate at ' + (n - 1));
+        throw new RangeError('Unmatched lead surrogate at ' + (n - 1))
       }
-      c1 = ((c1 & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
-      enc = String.fromCharCode(c1 >> 18 | 240, c1 >> 12 & 63 | 128, c1 >> 6 & 63 | 128, c1 & 63 | 128);
+      c1 = ((c1 & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000
+      enc = String.fromCharCode((c1 >> 18) | 240, ((c1 >> 12) & 63) | 128, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128)
     }
     if (enc !== null) {
       if (end > start) {
-        utftext += string.slice(start, end);
+        utftext += string.slice(start, end)
       }
-      utftext += enc;
-      start = end = n + 1;
+      utftext += enc
+      start = end = n + 1
     }
   }
 
   if (end > start) {
-    utftext += string.slice(start, stringl);
+    utftext += string.slice(start, stringl)
   }
 
-  return utftext;
-};
-//# sourceMappingURL=utf8_encode.js.map
+  return utftext
+}

package/python/index.js

@@ -1,4 +1 @@
-'use strict';
-
-module.exports.string = require('./string');
-//# sourceMappingURL=index.js.map
+module.exports.string = require('./string')

package/python/math/ceil.js

@@ -0,0 +1,17 @@
+module.exports = function ceil(x) {
+  //      discuss at: https://locutus.io/python/ceil/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the smallest integer >= x
+  //          note 2: JS Math.ceil(-0.5) returns -0, but Python returns 0
+  //       example 1: ceil(4.2)
+  //       returns 1: 5
+  //       example 2: ceil(-0.5)
+  //       returns 2: 0
+  //       example 3: ceil(3)
+  //       returns 3: 3
+
+  const result = Math.ceil(x)
+  // Convert -0 to 0 for Python compatibility
+  return Object.is(result, -0) ? 0 : result
+}

package/python/math/exp.js

@@ -0,0 +1,12 @@
+module.exports = function exp(x) {
+  //      discuss at: https://locutus.io/python/exp/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns e raised to the power of x
+  //       example 1: exp(0)
+  //       returns 1: 1
+  //       example 2: exp(1)
+  //       returns 2: 2.718281828459045
+
+  return Math.exp(x)
+}

package/python/math/fabs.js

@@ -0,0 +1,14 @@
+module.exports = function fabs(x) {
+  //      discuss at: https://locutus.io/python/fabs/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the absolute value of x as a float
+  //       example 1: fabs(-5)
+  //       returns 1: 5
+  //       example 2: fabs(3.14)
+  //       returns 2: 3.14
+  //       example 3: fabs(-2.5)
+  //       returns 3: 2.5
+
+  return Math.abs(x)
+}

package/python/math/factorial.js

@@ -0,0 +1,29 @@
+module.exports = function factorial(n) {
+  //      discuss at: https://locutus.io/python/factorial/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns n! (n factorial)
+  //       example 1: factorial(5)
+  //       returns 1: 120
+  //       example 2: factorial(0)
+  //       returns 2: 1
+  //       example 3: factorial(1)
+  //       returns 3: 1
+
+  n = parseInt(n, 10)
+
+  if (n < 0) {
+    throw new Error('factorial() not defined for negative values')
+  }
+
+  if (n === 0 || n === 1) {
+    return 1
+  }
+
+  let result = 1
+  for (let i = 2; i <= n; i++) {
+    result *= i
+  }
+
+  return result
+}

package/python/math/floor.js

@@ -0,0 +1,14 @@
+module.exports = function floor(x) {
+  //      discuss at: https://locutus.io/python/floor/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the largest integer <= x
+  //       example 1: floor(4.9)
+  //       returns 1: 4
+  //       example 2: floor(-0.5)
+  //       returns 2: -1
+  //       example 3: floor(3)
+  //       returns 3: 3
+
+  return Math.floor(x)
+}

package/python/math/gcd.js

@@ -0,0 +1,23 @@
+module.exports = function gcd(a, b) {
+  //      discuss at: https://locutus.io/python/gcd/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the greatest common divisor of a and b
+  //       example 1: gcd(48, 18)
+  //       returns 1: 6
+  //       example 2: gcd(0, 5)
+  //       returns 2: 5
+  //       example 3: gcd(7, 0)
+  //       returns 3: 7
+
+  a = Math.abs(parseInt(a, 10))
+  b = Math.abs(parseInt(b, 10))
+
+  while (b !== 0) {
+    const temp = b
+    b = a % b
+    a = temp
+  }
+
+  return a
+}