locutus 2.0.32 → 2.0.34

package/php/misc/pack.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function pack(format) {
   //  discuss at: https://locutus.io/php/pack/
   // original by: Tim de Koning (https://www.kingsquare.nl)
@@ -19,50 +17,49 @@ module.exports = function pack(format) {
   //   returns 3: 'Õ'
   //   example 4: pack('d', -100.876)
   //   returns 4: "\u0000\u0000\u0000\u0000\u00008YÀ"
-  //        test: skip-1
-
-  var formatPointer = 0;
-  var argumentPointer = 1;
-  var result = '';
-  var argument = '';
-  var i = 0;
-  var r = [];
-  var instruction = void 0,
-      quantifier = void 0,
-      word = void 0,
-      precisionBits = void 0,
-      exponentBits = void 0,
-      extraNullCount = void 0;
+
+  let formatPointer = 0
+  let argumentPointer = 1
+  let result = ''
+  let argument = ''
+  let i = 0
+  let r = []
+  let instruction
+  let quantifier
+  let word
+  let precisionBits
+  let exponentBits
+  let extraNullCount
 
   // vars used by float encoding
-  var bias = void 0;
-  var minExp = void 0;
-  var maxExp = void 0;
-  var minUnnormExp = void 0;
-  var status = void 0;
-  var exp = void 0;
-  var len = void 0;
-  var bin = void 0;
-  var signal = void 0;
-  var n = void 0;
-  var intPart = void 0;
-  var floatPart = void 0;
-  var lastBit = void 0;
-  var rounded = void 0;
-  var j = void 0;
-  var k = void 0;
-  var tmpResult = void 0;
+  let bias
+  let minExp
+  let maxExp
+  let minUnnormExp
+  let status
+  let exp
+  let len
+  let bin
+  let signal
+  let n
+  let intPart
+  let floatPart
+  let lastBit
+  let rounded
+  let j
+  let k
+  let tmpResult
 
   while (formatPointer < format.length) {
-    instruction = format.charAt(formatPointer);
-    quantifier = '';
-    formatPointer++;
+    instruction = format.charAt(formatPointer)
+    quantifier = ''
+    formatPointer++
     while (formatPointer < format.length && format.charAt(formatPointer).match(/[\d*]/) !== null) {
-      quantifier += format.charAt(formatPointer);
-      formatPointer++;
+      quantifier += format.charAt(formatPointer)
+      formatPointer++
     }
     if (quantifier === '') {
-      quantifier = '1';
+      quantifier = '1'
     }
 
     // Now pack variables: 'quantifier' times 'instruction'
@@ -72,59 +69,59 @@ module.exports = function pack(format) {
         // NUL-padded string
         // SPACE-padded string
         if (typeof arguments[argumentPointer] === 'undefined') {
-          throw new Error('Warning:  pack() Type ' + instruction + ': not enough arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': not enough arguments')
         } else {
-          argument = String(arguments[argumentPointer]);
+          argument = String(arguments[argumentPointer])
         }
         if (quantifier === '*') {
-          quantifier = argument.length;
+          quantifier = argument.length
         }
         for (i = 0; i < quantifier; i++) {
           if (typeof argument[i] === 'undefined') {
             if (instruction === 'a') {
-              result += String.fromCharCode(0);
+              result += String.fromCharCode(0)
             } else {
-              result += ' ';
+              result += ' '
             }
           } else {
-            result += argument[i];
+            result += argument[i]
           }
         }
-        argumentPointer++;
-        break;
+        argumentPointer++
+        break
       case 'h':
       case 'H':
         // Hex string, low nibble first
         // Hex string, high nibble first
         if (typeof arguments[argumentPointer] === 'undefined') {
-          throw new Error('Warning: pack() Type ' + instruction + ': not enough arguments');
+          throw new Error('Warning: pack() Type ' + instruction + ': not enough arguments')
         } else {
-          argument = arguments[argumentPointer];
+          argument = arguments[argumentPointer]
         }
         if (quantifier === '*') {
-          quantifier = argument.length;
+          quantifier = argument.length
         }
         if (quantifier > argument.length) {
-          var msg = 'Warning: pack() Type ' + instruction + ': not enough characters in string';
-          throw new Error(msg);
+          const msg = 'Warning: pack() Type ' + instruction + ': not enough characters in string'
+          throw new Error(msg)
         }
 
         for (i = 0; i < quantifier; i += 2) {
           // Always get per 2 bytes...
-          word = argument[i];
+          word = argument[i]
           if (i + 1 >= quantifier || typeof argument[i + 1] === 'undefined') {
-            word += '0';
+            word += '0'
           } else {
-            word += argument[i + 1];
+            word += argument[i + 1]
           }
           // The fastest way to reverse?
           if (instruction === 'h') {
-            word = word[1] + word[0];
+            word = word[1] + word[0]
           }
-          result += String.fromCharCode(parseInt(word, 16));
+          result += String.fromCharCode(parseInt(word, 16))
         }
-        argumentPointer++;
-        break;
+        argumentPointer++
+        break
 
       case 'c':
       case 'C':
@@ -132,17 +129,17 @@ module.exports = function pack(format) {
         // unsigned char
         // c and C is the same in pack
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments')
         }
 
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(arguments[argumentPointer]);
-          argumentPointer++;
+          result += String.fromCharCode(arguments[argumentPointer])
+          argumentPointer++
         }
-        break;
+        break
 
       case 's':
       case 'S':
@@ -151,34 +148,34 @@ module.exports = function pack(format) {
         // unsigned short (always 16 bit, machine byte order)
         // s and S is the same in pack
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments')
         }
 
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(arguments[argumentPointer] & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 8 & 0xff);
-          argumentPointer++;
+          result += String.fromCharCode(arguments[argumentPointer] & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 8) & 0xff)
+          argumentPointer++
         }
-        break;
+        break
 
       case 'n':
         // unsigned short (always 16 bit, big endian byte order)
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning: pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning: pack() Type ' + instruction + ': too few arguments')
         }
 
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(arguments[argumentPointer] >> 8 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] & 0xff);
-          argumentPointer++;
+          result += String.fromCharCode((arguments[argumentPointer] >> 8) & 0xff)
+          result += String.fromCharCode(arguments[argumentPointer] & 0xff)
+          argumentPointer++
         }
-        break;
+        break
 
       case 'i':
       case 'I':
@@ -191,194 +188,205 @@ module.exports = function pack(format) {
         // unsigned long (always 32 bit, machine byte order)
         // unsigned long (always 32 bit, little endian byte order)
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments')
         }
 
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(arguments[argumentPointer] & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 8 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 16 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 24 & 0xff);
-          argumentPointer++;
+          result += String.fromCharCode(arguments[argumentPointer] & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 8) & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 16) & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 24) & 0xff)
+          argumentPointer++
         }
 
-        break;
+        break
       case 'N':
         // unsigned long (always 32 bit, big endian byte order)
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments')
         }
 
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(arguments[argumentPointer] >> 24 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 16 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] >> 8 & 0xff);
-          result += String.fromCharCode(arguments[argumentPointer] & 0xff);
-          argumentPointer++;
+          result += String.fromCharCode((arguments[argumentPointer] >> 24) & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 16) & 0xff)
+          result += String.fromCharCode((arguments[argumentPointer] >> 8) & 0xff)
+          result += String.fromCharCode(arguments[argumentPointer] & 0xff)
+          argumentPointer++
         }
-        break;
+        break
 
       case 'f':
       case 'd':
         // float (machine dependent size and representation)
         // double (machine dependent size and representation)
         // version based on IEEE754
-        precisionBits = 23;
-        exponentBits = 8;
+        precisionBits = 23
+        exponentBits = 8
         if (instruction === 'd') {
-          precisionBits = 52;
-          exponentBits = 11;
+          precisionBits = 52
+          exponentBits = 11
         }
 
         if (quantifier === '*') {
-          quantifier = arguments.length - argumentPointer;
+          quantifier = arguments.length - argumentPointer
         }
         if (quantifier > arguments.length - argumentPointer) {
-          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments');
+          throw new Error('Warning:  pack() Type ' + instruction + ': too few arguments')
         }
         for (i = 0; i < quantifier; i++) {
-          argument = arguments[argumentPointer];
-          bias = Math.pow(2, exponentBits - 1) - 1;
-          minExp = -bias + 1;
-          maxExp = bias;
-          minUnnormExp = minExp - precisionBits;
-          status = isNaN(n = parseFloat(argument)) || n === -Infinity || n === +Infinity ? n : 0;
-          exp = 0;
-          len = 2 * bias + 1 + precisionBits + 3;
-          bin = new Array(len);
-          signal = (n = status !== 0 ? 0 : n) < 0;
-          n = Math.abs(n);
-          intPart = Math.floor(n);
-          floatPart = n - intPart;
-
-          for (k = len; k;) {
-            bin[--k] = 0;
+          argument = arguments[argumentPointer]
+          bias = Math.pow(2, exponentBits - 1) - 1
+          minExp = -bias + 1
+          maxExp = bias
+          minUnnormExp = minExp - precisionBits
+          status = isNaN((n = parseFloat(argument))) || n === -Infinity || n === +Infinity ? n : 0
+          exp = 0
+          len = 2 * bias + 1 + precisionBits + 3
+          bin = new Array(len)
+          signal = (n = status !== 0 ? 0 : n) < 0
+          n = Math.abs(n)
+          intPart = Math.floor(n)
+          floatPart = n - intPart
+
+          for (k = len; k; ) {
+            bin[--k] = 0
           }
-          for (k = bias + 2; intPart && k;) {
-            bin[--k] = intPart % 2;
-            intPart = Math.floor(intPart / 2);
+          for (k = bias + 2; intPart && k; ) {
+            bin[--k] = intPart % 2
+            intPart = Math.floor(intPart / 2)
           }
           for (k = bias + 1; floatPart > 0 && k; --floatPart) {
-            bin[++k] = ((floatPart *= 2) >= 1) - 0;
+            bin[++k] = ((floatPart *= 2) >= 1) - 0
+          }
+          for (k = -1; ++k < len && !bin[k]; ) {
+            /* skip leading zeros */
           }
-          for (k = -1; ++k < len && !bin[k];) {}
 
           // @todo: Make this more readable:
-          var key = (lastBit = precisionBits - 1 + (k = (exp = bias + 1 - k) >= minExp && exp <= maxExp ? k + 1 : bias + 1 - (exp = minExp - 1))) + 1;
+          const key =
+            (lastBit =
+              precisionBits -
+              1 +
+              (k = (exp = bias + 1 - k) >= minExp && exp <= maxExp ? k + 1 : bias + 1 - (exp = minExp - 1))) + 1
 
           if (bin[key]) {
             if (!(rounded = bin[lastBit])) {
-              for (j = lastBit + 2; !rounded && j < len; rounded = bin[j++]) {}
+              for (j = lastBit + 2; !rounded && j < len; rounded = bin[j++]) {
+                /* find if any trailing bit is set */
+              }
+            }
+            for (j = lastBit + 1; rounded && --j >= 0; (bin[j] = !bin[j] - 0) && (rounded = 0)) {
+              /* propagate rounding carry */
             }
-            for (j = lastBit + 1; rounded && --j >= 0; (bin[j] = !bin[j] - 0) && (rounded = 0)) {}
           }
 
-          for (k = k - 2 < 0 ? -1 : k - 3; ++k < len && !bin[k];) {}
+          for (k = k - 2 < 0 ? -1 : k - 3; ++k < len && !bin[k]; ) {
+            /* skip leading zeros after rounding */
+          }
 
           if ((exp = bias + 1 - k) >= minExp && exp <= maxExp) {
-            ++k;
+            ++k
           } else {
             if (exp < minExp) {
               if (exp !== bias + 1 - len && exp < minUnnormExp) {
                 // "encodeFloat::float underflow"
               }
-              k = bias + 1 - (exp = minExp - 1);
+              k = bias + 1 - (exp = minExp - 1)
             }
           }
 
           if (intPart || status !== 0) {
-            exp = maxExp + 1;
-            k = bias + 2;
+            exp = maxExp + 1
+            k = bias + 2
             if (status === -Infinity) {
-              signal = 1;
+              signal = 1
             } else if (isNaN(status)) {
-              bin[k] = 1;
+              bin[k] = 1
             }
           }
 
-          n = Math.abs(exp + bias);
-          tmpResult = '';
+          n = Math.abs(exp + bias)
+          tmpResult = ''
 
-          for (j = exponentBits + 1; --j;) {
-            tmpResult = n % 2 + tmpResult;
-            n = n >>= 1;
+          for (j = exponentBits + 1; --j; ) {
+            tmpResult = (n % 2) + tmpResult
+            n = n >>= 1
           }
 
-          n = 0;
-          j = 0;
-          k = (tmpResult = (signal ? '1' : '0') + tmpResult + bin.slice(k, k + precisionBits).join('')).length;
-          r = [];
+          n = 0
+          j = 0
+          k = (tmpResult = (signal ? '1' : '0') + tmpResult + bin.slice(k, k + precisionBits).join('')).length
+          r = []
 
-          for (; k;) {
-            n += (1 << j) * tmpResult.charAt(--k);
+          for (; k; ) {
+            n += (1 << j) * tmpResult.charAt(--k)
             if (j === 7) {
-              r[r.length] = String.fromCharCode(n);
-              n = 0;
+              r[r.length] = String.fromCharCode(n)
+              n = 0
             }
-            j = (j + 1) % 8;
+            j = (j + 1) % 8
           }
 
-          r[r.length] = n ? String.fromCharCode(n) : '';
-          result += r.join('');
-          argumentPointer++;
+          r[r.length] = n ? String.fromCharCode(n) : ''
+          result += r.join('')
+          argumentPointer++
         }
-        break;
+        break
 
       case 'x':
         // NUL byte
         if (quantifier === '*') {
-          throw new Error("Warning: pack(): Type x: '*' ignored");
+          throw new Error("Warning: pack(): Type x: '*' ignored")
         }
         for (i = 0; i < quantifier; i++) {
-          result += String.fromCharCode(0);
+          result += String.fromCharCode(0)
         }
-        break;
+        break
 
       case 'X':
         // Back up one byte
         if (quantifier === '*') {
-          throw new Error("Warning: pack(): Type X: '*' ignored");
+          throw new Error("Warning: pack(): Type X: '*' ignored")
         }
         for (i = 0; i < quantifier; i++) {
           if (result.length === 0) {
-            throw new Error('Warning: pack(): Type X:' + ' outside of string');
+            throw new Error('Warning: pack(): Type X:' + ' outside of string')
           } else {
-            result = result.substring(0, result.length - 1);
+            result = result.substring(0, result.length - 1)
           }
         }
-        break;
+        break
 
       case '@':
         // NUL-fill to absolute position
         if (quantifier === '*') {
-          throw new Error("Warning: pack(): Type X: '*' ignored");
+          throw new Error("Warning: pack(): Type X: '*' ignored")
         }
         if (quantifier > result.length) {
-          extraNullCount = quantifier - result.length;
+          extraNullCount = quantifier - result.length
           for (i = 0; i < extraNullCount; i++) {
-            result += String.fromCharCode(0);
+            result += String.fromCharCode(0)
           }
         }
         if (quantifier < result.length) {
-          result = result.substring(0, quantifier);
+          result = result.substring(0, quantifier)
         }
-        break;
+        break
 
       default:
-        throw new Error('Warning: pack() Type ' + instruction + ': unknown format code');
+        throw new Error('Warning: pack() Type ' + instruction + ': unknown format code')
     }
   }
   if (argumentPointer < arguments.length) {
-    var msg2 = 'Warning: pack(): ' + (arguments.length - argumentPointer) + ' arguments unused';
-    throw new Error(msg2);
+    const msg2 = 'Warning: pack(): ' + (arguments.length - argumentPointer) + ' arguments unused'
+    throw new Error(msg2)
   }
 
-  return result;
-};
-//# sourceMappingURL=pack.js.map
+  return result
+}

package/php/misc/uniqid.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function uniqid(prefix, moreEntropy) {
   //  discuss at: https://locutus.io/php/uniqid/
   // original by: Kevin van Zonneveld (https://kvz.io)
@@ -16,44 +14,43 @@ module.exports = function uniqid(prefix, moreEntropy) {
   //   returns 3: true
 
   if (typeof prefix === 'undefined') {
-    prefix = '';
+    prefix = ''
   }
 
-  var retId = void 0;
-  var _formatSeed = function _formatSeed(seed, reqWidth) {
-    seed = parseInt(seed, 10).toString(16); // to hex str
+  let retId
+  const _formatSeed = function (seed, reqWidth) {
+    seed = parseInt(seed, 10).toString(16) // to hex str
     if (reqWidth < seed.length) {
       // so long we split
-      return seed.slice(seed.length - reqWidth);
+      return seed.slice(seed.length - reqWidth)
     }
     if (reqWidth > seed.length) {
       // so short we pad
-      return Array(1 + (reqWidth - seed.length)).join('0') + seed;
+      return new Array(1 + (reqWidth - seed.length)).join('0') + seed
     }
-    return seed;
-  };
+    return seed
+  }
 
-  var $global = typeof window !== 'undefined' ? window : global;
-  $global.$locutus = $global.$locutus || {};
-  var $locutus = $global.$locutus;
-  $locutus.php = $locutus.php || {};
+  const $global = typeof window !== 'undefined' ? window : global
+  $global.$locutus = $global.$locutus || {}
+  const $locutus = $global.$locutus
+  $locutus.php = $locutus.php || {}
 
   if (!$locutus.php.uniqidSeed) {
     // init seed with big random int
-    $locutus.php.uniqidSeed = Math.floor(Math.random() * 0x75bcd15);
+    $locutus.php.uniqidSeed = Math.floor(Math.random() * 0x75bcd15)
   }
-  $locutus.php.uniqidSeed++;
+  $locutus.php.uniqidSeed++
 
   // start with prefix, add current milliseconds hex string
-  retId = prefix;
-  retId += _formatSeed(parseInt(new Date().getTime() / 1000, 10), 8);
+  retId = prefix
+  retId += _formatSeed(parseInt(new Date().getTime() / 1000, 10), 8)
   // add seed hex string
-  retId += _formatSeed($locutus.php.uniqidSeed, 5);
+  retId += _formatSeed($locutus.php.uniqidSeed, 5)
   if (moreEntropy) {
     // for more entropy we add a float lower to 10
-    retId += (Math.random() * 10).toFixed(8).toString();
+    retId += (Math.random() * 10).toFixed(8).toString()
   }
 
-  return retId;
-};
-//# sourceMappingURL=uniqid.js.map
+  return retId
+}