@webalternatif/js-core 1.1.2 → 1.2.0

package/dist/esm/math.js

@@ -1,19 +1,20 @@
 import { each } from "./traversal.js";
 import { isArray, isFunction, isObject } from "./is.js";
 import { reverse } from "./string.js";
-export const round = function (val, precision = 0) {
+export var round = function round(val) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   return Math.round(val * Math.pow(10, precision)) / Math.pow(10, precision);
 };
-export const floorTo = function (n, precision) {
+export var floorTo = function floorTo(n, precision) {
   if (precision <= 0) throw new Error('Precision must be greater than 0');
   return round(Math.floor(n / precision) * precision, 6);
 };
-export const plancher = floorTo;
-export const min = function (list, cmp_func) {
+export var plancher = floorTo;
+export var min = function min(list, cmp_func) {
   if (isArray(list)) {
     return Math.min.apply(null, list);
   }
-  let min;
+  var min;
   cmp_func = isFunction(cmp_func) ? cmp_func : function (a, b) {
     return a < b ? -1 : 1;
   };
@@ -28,11 +29,11 @@ export const min = function (list, cmp_func) {
   }
   return min;
 };
-export const max = function (list, cmp_func) {
+export var max = function max(list, cmp_func) {
   if (isArray(list)) {
     return Math.max.apply(null, list);
   }
-  let max;
+  var max;
   cmp_func = isFunction(cmp_func) ? cmp_func : function (a, b) {
     return b - a;
   };
@@ -54,7 +55,7 @@ export const max = function (list, cmp_func) {
  * @param {number} n
  * @returns {string}
  */
-export const dec2hex = function (n) {
+export var dec2hex = function dec2hex(n) {
   return n.toString(16);
 };
 
@@ -64,12 +65,12 @@ export const dec2hex = function (n) {
  * @param {string} hex
  * @returns {number}
  */
-export const hex2dec = function (hex) {
+export var hex2dec = function hex2dec(hex) {
   hex = reverse(hex + '').toUpperCase();
-  const c = '0123456789ABCDEF';
-  let value = 0;
-  each(hex, (i, char) => {
-    const index = c.indexOf(char);
+  var c = '0123456789ABCDEF';
+  var value = 0;
+  each(hex, function (i, _char) {
+    var index = c.indexOf(_char);
     if (index === -1) {
       value = 0;
       return false;

package/dist/esm/random.js

@@ -1,24 +1,24 @@
-export const uniqid = function () {
+export var uniqid = function uniqid() {
   return randAlpha(10);
 };
-export const randAlpha = function (n) {
+export var randAlpha = function randAlpha(n) {
   return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
 };
-export const randAlphaCs = function (n) {
+export var randAlphaCs = function randAlphaCs(n) {
   return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
 };
-export const randAlphaNum = function (n) {
+export var randAlphaNum = function randAlphaNum(n) {
   return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
 };
-export const randAlphaNumCs = function (n) {
+export var randAlphaNumCs = function randAlphaNumCs(n) {
   return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
 };
-export const randNum = function (n) {
+export var randNum = function randNum(n) {
   return rand("0,1,2,3,4,5,6,7,8,9".split(','), n);
 };
-export const rand = function (range, n) {
-  let rand = "";
-  for (let i = 0; i < n; i++) {
+export var rand = function rand(range, n) {
+  var rand = "";
+  for (var i = 0; i < n; i++) {
     rand += range[Math.floor(Math.random() * 1000) % range.length];
   }
   return rand;

package/dist/esm/string.js

@@ -1,46 +1,57 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 import { isArray, isFloat, isInteger, isObject, isPlainObject, isString, isUndefined } from "./is.js";
 import { dec2hex, hex2dec, round } from "./math.js";
 import { inArray } from "./array.js";
 import { each, foreach, map } from "./traversal.js";
 import { translate } from "./i18n.js";
-export const trim = function (str, char = '\\s') {
-  return ltrim(rtrim(str, char), char);
+export var trim = function trim(str) {
+  var _char = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '\\s';
+  return ltrim(rtrim(str, _char), _char);
 };
-export const ltrim = function (str, char = '\\s') {
-  return str.replace(new RegExp(`^${char}+`, 'g'), '');
+export var ltrim = function ltrim(str) {
+  var _char2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '\\s';
+  return str.replace(new RegExp("^".concat(_char2, "+"), 'g'), '');
 };
-export const rtrim = function (str, char = '\\s') {
-  return str.replace(new RegExp(`${char}+$`, 'g'), '');
+export var rtrim = function rtrim(str) {
+  var _char3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '\\s';
+  return str.replace(new RegExp("".concat(_char3, "+$"), 'g'), '');
 };
-export const stripMultipleSpaces = function (str) {
+export var stripMultipleSpaces = function stripMultipleSpaces(str) {
   return str.trim().replace(/ +/g, ' ');
 };
-export const noAccent = function (str) {
+export var noAccent = function noAccent(str) {
   return str.replace(/[àäâ]/g, 'a').replace(/[èéêë]/g, 'e').replace(/[îïí]/g, 'i').replace(/[öô]/g, 'o').replace(/[üù]/g, 'u').replace(/ç/g, 'c').replace(/ÿ/g, 'y').replace(/[ÀÄÂ]/g, 'A').replace(/[ÈÉÊË]/g, 'E').replace(/[ÎÏÍ]/g, 'I').replace(/[ÖÔ]/g, 'O').replace(/[ÜÙ]/g, 'U').replace(/Ç/g, 'C').replace(/Ÿ/g, 'Y');
 };
-export const br2nl = function (str) {
+export var br2nl = function br2nl(str) {
   return str.split(/<br\s*\/*>/).join('\n');
 };
-export const nl2br = function (str) {
+export var nl2br = function nl2br(str) {
   return str.split('\n').join('<br>');
 };
-export const ucfirst = function (str) {
+export var ucfirst = function ucfirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
-export const lcfirst = function (str) {
+export var lcfirst = function lcfirst(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 };
-export const insertTag = function (str, tag, position = 0, length = 0) {
-  let startTag = `<${tag}>`;
-  let endTag = `</${tag}>`;
+export var insertTag = function insertTag(str, tag) {
+  var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var startTag = "<".concat(tag, ">");
+  var endTag = "</".concat(tag, ">");
   if (['br', 'hr', 'img', 'link', 'input'].includes(tag)) {
-    startTag = `<${tag}/>`;
+    startTag = "<".concat(tag, "/>");
     endTag = '';
   }
   return str.slice(0, position) + startTag + str.slice(position, position + length) + endTag + str.slice(position + length);
 };
-export const substringIndex = function (str, delimiter, index) {
-  let input = str + '',
+export var substringIndex = function substringIndex(str, delimiter, index) {
+  var input = str + '',
     arr = input.split(delimiter);
   if (index > 0) {
     arr.splice(index, arr.length - index);
@@ -49,57 +60,63 @@ export const substringIndex = function (str, delimiter, index) {
   }
   return arr.join(delimiter);
 };
-export const insert = (str, ins, n) => {
+export var insert = function insert(str, ins, n) {
   if (n >= str.length) {
     return str;
   }
-  return [...str].reduce((newStr, char, index) => {
+  return _toConsumableArray(str).reduce(function (newStr, _char4, index) {
     if (index > 0 && index % n === 0) {
-      return newStr + ins + char;
+      return newStr + ins + _char4;
     }
-    return newStr + char;
+    return newStr + _char4;
   }, '');
 };
-export const reverse = function (str) {
-  let res = [];
-  for (let i = 0; i < str.length; i++) {
+export var reverse = function reverse(str) {
+  var res = [];
+  for (var i = 0; i < str.length; i++) {
     res.unshift(str[i]);
   }
   return res.join('');
 };
-export const thousandSeparator = function (value, separator = '.', pointDecimal = '.') {
+export var thousandSeparator = function thousandSeparator(value) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.';
+  var pointDecimal = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
   if (isUndefined(value) || null === value) {
     return value;
   }
   value = (value + '').replace(',', '.');
   if (Math.abs(value) >= 1000) {
-    let intval = Math[value >= 1000 ? 'floor' : 'ceil'](value) + '';
-    let newval = reverse(insert(reverse(intval), reverse(separator), 3));
+    var intval = Math[value >= 1000 ? 'floor' : 'ceil'](value) + '';
+    var newval = reverse(insert(reverse(intval), reverse(separator), 3));
     return value.indexOf('.') > 0 ? newval + pointDecimal + substringIndex(value, '.', -1) : newval;
   }
   return (value + '').replace('.', pointDecimal);
 };
-export const numberFormat = function (number, decimals = 2, forceCentimes = false, thousandSep = '', pointDecimal = '.') {
+export var numberFormat = function numberFormat(number) {
+  var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  var forceCentimes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var thousandSep = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+  var pointDecimal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '.';
   number = number ? number + '' : '0';
   number = round(parseFloat(number.replace(',', '.')), decimals) + '';
   if (decimals === 0) {
     return thousandSeparator(number, thousandSep, pointDecimal);
   }
-  const pos = number.lastIndexOf('.');
+  var pos = number.lastIndexOf('.');
   if (-1 === pos) {
     if (true === forceCentimes) {
       number += pointDecimal + repeat('0', decimals);
     }
     return thousandSeparator(number, thousandSep, pointDecimal);
   }
-  const digits = number.slice(pos + 1);
-  const nbDigits = digits.length;
+  var digits = number.slice(pos + 1);
+  var nbDigits = digits.length;
   if (decimals > nbDigits) {
     return thousandSeparator(number + '0'.repeat(decimals - nbDigits), thousandSep, pointDecimal);
   }
   return thousandSeparator(number.slice(0, pos + 1 + decimals), thousandSep, pointDecimal);
 };
-export const toPrice = numberFormat;
+export var toPrice = numberFormat;
 
 /**
  * Pads a string to a specified length with a specified string and padding type
@@ -110,7 +127,9 @@ export const toPrice = numberFormat;
  * @param {string} [pad_type]
  * @returns {string}
  */
-export const pad = function (str, pad_length, pad_str = ' ', pad_type = 'left') {
+export var pad = function pad(str, pad_length) {
+  var pad_str = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' ';
+  var pad_type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'left';
   if (isUndefined(pad_length) || str.length >= pad_length || !inArray(pad_type, ['left', 'right'])) {
     return str;
   }
@@ -137,14 +156,15 @@ export const pad = function (str, pad_length, pad_str = ' ', pad_type = 'left')
  * // Using an array of RGB components
  * rgb2hex([255, 0, 0]); // Returns 'FF0000'
  */
-export const rgb2hex = function (r, g, b) {
+var _rgb2hex = function rgb2hex(r, g, b) {
   if (isArray(r)) {
-    return rgb2hex(...r);
+    return _rgb2hex.apply(void 0, _toConsumableArray(r));
   }
   if (!isInteger(r) || !isInteger(g) || !isInteger(b)) return '';
   return [pad(dec2hex(parseInt(r)), 2, '0').toUpperCase(), pad(dec2hex(parseInt(g)), 2, '0').toUpperCase(), pad(dec2hex(parseInt(b)), 2, '0').toUpperCase()].join('');
 };
-export const rgbtohex = rgb2hex;
+export { _rgb2hex as rgb2hex };
+export var rgbtohex = _rgb2hex;
 
 /**
  * Converts a hexadecimal color to RGB values.
@@ -152,20 +172,24 @@ export const rgbtohex = rgb2hex;
  * @param {string} hex - The hexadecimal value (e.g #FF0000)
  * @returns {number[]} The RGB color array (e.g [255, 0, 0]).
  */
-export const hex2rgb = function (hex) {
+export var hex2rgb = function hex2rgb(hex) {
   if (!isString(hex) || !hex.length) return [];
   hex = hex.slice(-6).toUpperCase();
   if (hex.length < 6) {
-    hex = map(hex.slice(-3), (i, h) => h + '' + h).join('');
+    hex = map(hex.slice(-3), function (i, h) {
+      return h + '' + h;
+    }).join('');
   }
-  for (let i = 0; i < hex.length; i++) {
+  for (var i = 0; i < hex.length; i++) {
     if (-1 === '0123456789ABCDEF'.indexOf(hex[i])) {
       return [];
     }
   }
-  return map(insert(hex, ',', 2).split(','), (i, h) => hex2dec(h));
+  return map(insert(hex, ',', 2).split(','), function (i, h) {
+    return hex2dec(h);
+  });
 };
-export const hextorgb = hex2rgb;
+export var hextorgb = hex2rgb;
 
 /**
  * Parses a URL string into its components.
@@ -187,11 +211,11 @@ export const hextorgb = hex2rgb;
  * @property {string} [query] - The query string (e.g., `key=value&key2=value2`).
  * @property {string} [fragment] - The fragment (hash) of the URL (e.g., `#section`).
  */
-export const parse_url = function (str) {
-  const key = ['source', 'scheme', 'authority', 'userInfo', 'user', 'pass', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'fragment'],
+export var parse_url = function parse_url(str) {
+  var key = ['source', 'scheme', 'authority', 'userInfo', 'user', 'pass', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'fragment'],
     parser = /^(?:([^:\/?#]+):)?(?:\/\/()(?:(?:()(?:([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?()(?:(()(?:(?:[^?#\/]*\/)*)()(?:[^?#]*))(?:\?([^#]*))?(?:#(.*))?)/;
-  const m = parser.exec(str);
-  let uri = {},
+  var m = parser.exec(str);
+  var uri = {},
     i = 14;
   while (i--) {
     if (m[i]) {
@@ -218,13 +242,14 @@ export const parse_url = function (str) {
  * addUrlParam('https://example.com', { key1: 'value1', key2: 'value2' });
  * // Returns: 'https://example.com?key1=value1&key2=value2'
  */
-export const addUrlParam = function (url, param, value = null) {
+var _addUrlParam = function addUrlParam(url, param) {
+  var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
   if (isPlainObject(param)) {
-    each(param, (key, val) => {
-      url = addUrlParam(url, key, val);
+    each(param, function (key, val) {
+      url = _addUrlParam(url, key, val);
     });
   } else {
-    let parseUrl = parse_url(url),
+    var parseUrl = parse_url(url),
       pos,
       hash = "";
     if ((pos = url.indexOf("#")) > -1) {
@@ -236,9 +261,9 @@ export const addUrlParam = function (url, param, value = null) {
     if (!parseUrl.query) {
       url += "?" + param + "=" + value + hash;
     } else {
-      const params = parseUrl.query.split('&');
-      let param_exists = false;
-      for (let i = 0; i < params.length; i++) {
+      var params = parseUrl.query.split('&');
+      var param_exists = false;
+      for (var i = 0; i < params.length; i++) {
         if (params[i].indexOf(param + "=") > -1) {
           param_exists = true;
           params[i] = param + "=" + value;
@@ -257,115 +282,125 @@ export const addUrlParam = function (url, param, value = null) {
   }
   return url;
 };
-export const decodeHtml = function (str) {
+export { _addUrlParam as addUrlParam };
+export var decodeHtml = function decodeHtml(str) {
   if (!isString(str)) return '';
   return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'");
 };
-export const htmlquotes = function (str) {
+export var htmlquotes = function htmlquotes(str) {
   if (!isString(str)) return '';
   return str.replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 };
-export const htmlsimplequotes = function (str) {
+export var htmlsimplequotes = function htmlsimplequotes(str) {
   if (!isString(str)) return '';
   return str.replace(/'/g, "&#039;");
 };
-export const repeat = function (str, n) {
+export var repeat = function repeat(str, n) {
   if (!isString(str) || !isFloat(n)) return '';
   return new Array(Math.floor(n) + 1).join(str);
 };
-export const stripTags = function (str, tag) {
+export var stripTags = function stripTags(str, tag) {
   if (isString(tag)) {
-    const rStripTags = new RegExp(`<${tag}[^>]*>(.*?)</${tag}>|<${tag}[^>]*\/>`, 'ig');
+    var rStripTags = new RegExp("<".concat(tag, "[^>]*>(.*?)</").concat(tag, ">|<").concat(tag, "[^>]*/>"), 'ig');
     while (rStripTags.test(str)) str = str.replace(rStripTags, '$1');
     return str;
   }
   return str.replace(/(<([^>]+)>)/ig, "");
 };
-export const toUrl = function (str) {
+export var toUrl = function toUrl(str) {
   return trim(noAccent(str).toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-{2,}/g, '-'), '-');
 };
 
 /**
  * @see http://stackoverflow.com/questions/3115150/how-to-escape-regular-expression-special-characters-using-javascript
  */
-export const escapeRegex = function (str) {
+export var escapeRegex = function escapeRegex(str) {
   return str.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&").replace(/[\n\t]/g, " ");
 };
-export const camelCase = function (str) {
-  foreach('-_', char => {
-    str = trim(str, char).replace(new RegExp(`${char}+`, 'g'), char);
+export var camelCase = function camelCase(str) {
+  foreach('-_', function (_char5) {
+    str = trim(str, _char5).replace(new RegExp("".concat(_char5, "+"), 'g'), _char5);
   });
   str = trim(str).replace(/\s+/g, '-');
-  return str.toLowerCase().replace(/[_-](\w)/g, (match, p1) => p1.toUpperCase());
+  return str.toLowerCase().replace(/[_-](\w)/g, function (match, p1) {
+    return p1.toUpperCase();
+  });
 };
-export const format = function (str, ...args) {
+export var format = function format(str) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
   if (args.length) {
-    each(args, (i, arg) => {
+    each(args, function (i, arg) {
       if (isString(arg)) {
-        const o = {};
+        var o = {};
         o[i] = arg;
         arg = o;
       }
-      each(arg, (placeholder, replacement) => {
-        str = str.replace(new RegExp('\\{' + placeholder + '\\}', 'gm'), match => isUndefined(replacement) ? match : replacement);
+      each(arg, function (placeholder, replacement) {
+        str = str.replace(new RegExp('\\{' + placeholder + '\\}', 'gm'), function (match) {
+          return isUndefined(replacement) ? match : replacement;
+        });
       });
     });
   }
   return str;
 };
-export const f = format;
+export var f = format;
 
 /**
  * @see https://stackoverflow.com/questions/7627000/javascript-convert-string-to-safe-class-name-for-css
  */
-export const toCssClassName = function (str) {
-  return str.replace(/[^a-z0-9_-]/ig, s => {
-    const c = s.charCodeAt(0);
+export var toCssClassName = function toCssClassName(str) {
+  return str.replace(/[^a-z0-9_-]/ig, function (s) {
+    var c = s.charCodeAt(0);
     if (c === 32) return '-';
     return '__' + ('000' + c.toString(16)).slice(-4);
   });
 };
-export const hilite = function (str, req, tag = 'strong') {
+export var hilite = function hilite(str, req) {
+  var tag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'strong';
   str = decodeHtml(str);
-  let str_folded = noAccent(str).toLowerCase().replace(/[\[\]]+/g, '');
-  let q_folded,
+  var str_folded = noAccent(str).toLowerCase().replace(/[\[\]]+/g, '');
+  var q_folded,
     re,
     hilite_hints = '';
   if (!isArray(req)) {
     req = [req];
   }
-  each(req, (i, q) => {
+  each(req, function (i, q) {
     if (q.length) {
       q = decodeHtml(q);
       q_folded = noAccent(q).toLowerCase().replace(/[\[\]]+/g, '');
       re = new RegExp(escapeRegex(q_folded), 'g');
-      hilite_hints = str_folded.replace(re, `[${q_folded}]`);
+      hilite_hints = str_folded.replace(re, "[".concat(q_folded, "]"));
       str_folded = hilite_hints;
     }
   });
   if (!hilite_hints.length) {
     return str;
   }
-  let spos = 0;
-  let highlighted = '';
-  let dirHook = 'end';
-  each(hilite_hints, (i, hint) => {
-    const c = str.charAt(spos);
+  var spos = 0;
+  var highlighted = '';
+  var dirHook = 'end';
+  each(hilite_hints, function (i, hint) {
+    var c = str.charAt(spos);
     if (hint === '[' && dirHook === 'end') {
-      highlighted += `<${tag}>`;
+      highlighted += "<".concat(tag, ">");
       dirHook = 'start';
     } else if (hint === ']' && dirHook === 'start') {
-      highlighted += `</${tag}>`;
+      highlighted += "</".concat(tag, ">");
       dirHook = 'end';
     } else {
       spos += 1;
       highlighted += c;
     }
   });
-  return highlighted.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(new RegExp(`&lt;${tag}&gt;`, 'g'), `<${tag}>`).replace(new RegExp(`&lt;/${tag}&gt;`, 'g'), `</${tag}>`).replace(new RegExp('&lt;br&gt;', 'g'), '<br>');
+  return highlighted.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(new RegExp("&lt;".concat(tag, "&gt;"), 'g'), "<".concat(tag, ">")).replace(new RegExp("&lt;/".concat(tag, "&gt;"), 'g'), "</".concat(tag, ">")).replace(new RegExp('&lt;br&gt;', 'g'), '<br>');
 };
-export const formatSize = function (bytes, decimalPoint = ',') {
-  let i = -1,
+export var formatSize = function formatSize(bytes) {
+  var decimalPoint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
+  var i = -1,
     decimals = 0;
   do {
     bytes /= 1024;
@@ -374,18 +409,18 @@ export const formatSize = function (bytes, decimalPoint = ',') {
   if (!isInteger(bytes)) {
     decimals = 1;
   }
-  const units = map(['k', 'M', 'G', 'T', 'P', 'E'], (i, prefix) => {
+  var units = map(['k', 'M', 'G', 'T', 'P', 'E'], function (i, prefix) {
     return prefix + translate('unitByte');
   });
   return numberFormat(Math.max(bytes, 0), decimals, true, '', decimalPoint) + ' ' + units[i];
 };
-export const compareMixAlphaDigits = (a, b) => {
+export var compareMixAlphaDigits = function compareMixAlphaDigits(a, b) {
   if (a === b) return 0;
   if (isInteger(a) && isInteger(b)) {
     return Math.sign(a - b);
   }
-  let startEq = '';
-  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+  var startEq = '';
+  for (var i = 0; i < Math.min(a.length, b.length); i++) {
     if (a.charAt(i) === b.charAt(i) && !isInteger(a)) {
       startEq += a.charAt(i);
     } else {
@@ -394,9 +429,9 @@ export const compareMixAlphaDigits = (a, b) => {
   }
   a = a.slice(startEq.length);
   b = b.slice(startEq.length);
-  let nbA = '';
-  let idxDigitA = null;
-  each(a, (i, c) => {
+  var nbA = '';
+  var idxDigitA = null;
+  each(a, function (i, c) {
     if (!nbA) {
       idxDigitA = i;
       if (c >= '0' && c <= '9') {
@@ -410,9 +445,9 @@ export const compareMixAlphaDigits = (a, b) => {
       return false;
     }
   });
-  let nbB = '';
-  let idxDigitB = null;
-  each(b, (i, c) => {
+  var nbB = '';
+  var idxDigitB = null;
+  each(b, function (i, c) {
     if (!nbB) {
       idxDigitB = i;
       if (c >= '0' && c <= '9') {

package/dist/esm/stringPrototype.js

@@ -1,13 +1,16 @@
 import { each } from "./traversal.js";
 import * as stringFunctions from "./string.js";
-each(Object.keys(stringFunctions), (i, name) => {
-  const f = stringFunctions[name],
+each(Object.keys(stringFunctions), function (i, name) {
+  var f = stringFunctions[name],
     p = String.prototype;
-  const origSF = p[name];
-  p[name] = function (...args) {
+  var origSF = p[name];
+  p[name] = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
     if (origSF && args.length === origSF.length) {
       return origSF.apply(this, args);
     }
-    return f(this, ...args);
+    return f.apply(void 0, [this].concat(args));
   };
 });