@webalternatif/js-core 1.1.1 → 1.1.3

package/dist/cjs/string.js

@@ -1,62 +1,57 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ucfirst = exports.trim = exports.toUrl = exports.toPrice = exports.toCssClassName = exports.thousandSeparator = exports.substringIndex = exports.stripTags = exports.stripMultipleSpaces = exports.rtrim = exports.rgbtohex = exports.rgb2hex = exports.reverse = exports.repeat = exports.parse_url = exports.pad = exports.numberFormat = exports.noAccent = exports.nl2br = exports.ltrim = exports.lcfirst = exports.insertTag = exports.insert = exports.htmlsimplequotes = exports.htmlquotes = exports.hilite = exports.hextorgb = exports.hex2rgb = exports.formatSize = exports.format = exports.f = exports.escapeRegex = exports.decodeHtml = exports.compareMixAlphaDigits = exports.camelCase = exports.br2nl = exports.addUrlParam = void 0;
-var _is = require("./is.js");
-var _math = require("./math.js");
-var _array = require("./array.js");
-var _traversal = require("./traversal.js");
-var _i18n = require("./i18n.js");
-const trim = function (str, char = '\\s') {
-  return ltrim(rtrim(str, char), char);
-};
-exports.trim = trim;
-const ltrim = function (str, char = '\\s') {
-  return str.replace(new RegExp(`^${char}+`, 'g'), '');
-};
-exports.ltrim = ltrim;
-const rtrim = function (str, char = '\\s') {
-  return str.replace(new RegExp(`${char}+$`, 'g'), '');
-};
-exports.rtrim = rtrim;
-const stripMultipleSpaces = function (str) {
+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 var trim = function trim(str) {
+  var _char = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '\\s';
+  return ltrim(rtrim(str, _char), _char);
+};
+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 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 var stripMultipleSpaces = function stripMultipleSpaces(str) {
   return str.trim().replace(/ +/g, ' ');
 };
-exports.stripMultipleSpaces = stripMultipleSpaces;
-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');
 };
-exports.noAccent = noAccent;
-const br2nl = function (str) {
+export var br2nl = function br2nl(str) {
   return str.split(/<br\s*\/*>/).join('\n');
 };
-exports.br2nl = br2nl;
-const nl2br = function (str) {
+export var nl2br = function nl2br(str) {
   return str.split('\n').join('<br>');
 };
-exports.nl2br = nl2br;
-const ucfirst = function (str) {
+export var ucfirst = function ucfirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
-exports.ucfirst = ucfirst;
-const lcfirst = function (str) {
+export var lcfirst = function lcfirst(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 };
-exports.lcfirst = lcfirst;
-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);
 };
-exports.insertTag = insertTag;
-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);
@@ -65,62 +60,63 @@ const substringIndex = function (str, delimiter, index) {
   }
   return arr.join(delimiter);
 };
-exports.substringIndex = substringIndex;
-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;
   }, '');
 };
-exports.insert = insert;
-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('');
 };
-exports.reverse = reverse;
-const thousandSeparator = function (value, separator = '.', pointDecimal = '.') {
-  if ((0, _is.isUndefined)(value) || null === value) {
+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);
 };
-exports.thousandSeparator = thousandSeparator;
-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 = (0, _math.round)(parseFloat(number.replace(',', '.')), decimals) + '';
+  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);
 };
-exports.numberFormat = numberFormat;
-const toPrice = exports.toPrice = numberFormat;
+export var toPrice = numberFormat;
 
 /**
  * Pads a string to a specified length with a specified string and padding type
@@ -131,8 +127,10 @@ const toPrice = exports.toPrice = numberFormat;
  * @param {string} [pad_type]
  * @returns {string}
  */
-const pad = function (str, pad_length, pad_str = ' ', pad_type = 'left') {
-  if ((0, _is.isUndefined)(pad_length) || str.length >= pad_length || !(0, _array.inArray)(pad_type, ['left', 'right'])) {
+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;
   }
   if (pad_type === 'left') {
@@ -158,16 +156,15 @@ const pad = function (str, pad_length, pad_str = ' ', pad_type = 'left') {
  * // Using an array of RGB components
  * rgb2hex([255, 0, 0]); // Returns 'FF0000'
  */
-exports.pad = pad;
-const rgb2hex = function (r, g, b) {
-  if ((0, _is.isArray)(r)) {
-    return rgb2hex(...r);
+var _rgb2hex = function rgb2hex(r, g, b) {
+  if (isArray(r)) {
+    return _rgb2hex.apply(void 0, _toConsumableArray(r));
   }
-  if (!(0, _is.isInteger)(r) || !(0, _is.isInteger)(g) || !(0, _is.isInteger)(b)) return '';
-  return [pad((0, _math.dec2hex)(parseInt(r)), 2, '0').toUpperCase(), pad((0, _math.dec2hex)(parseInt(g)), 2, '0').toUpperCase(), pad((0, _math.dec2hex)(parseInt(b)), 2, '0').toUpperCase()].join('');
+  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('');
 };
-exports.rgb2hex = rgb2hex;
-const rgbtohex = exports.rgbtohex = rgb2hex;
+export { _rgb2hex as rgb2hex };
+export var rgbtohex = _rgb2hex;
 
 /**
  * Converts a hexadecimal color to RGB values.
@@ -175,21 +172,24 @@ const rgbtohex = exports.rgbtohex = rgb2hex;
  * @param {string} hex - The hexadecimal value (e.g #FF0000)
  * @returns {number[]} The RGB color array (e.g [255, 0, 0]).
  */
-const hex2rgb = function (hex) {
-  if (!(0, _is.isString)(hex) || !hex.length) return [];
+export var hex2rgb = function hex2rgb(hex) {
+  if (!isString(hex) || !hex.length) return [];
   hex = hex.slice(-6).toUpperCase();
   if (hex.length < 6) {
-    hex = (0, _traversal.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 (0, _traversal.map)(insert(hex, ',', 2).split(','), (i, h) => (0, _math.hex2dec)(h));
+  return map(insert(hex, ',', 2).split(','), function (i, h) {
+    return hex2dec(h);
+  });
 };
-exports.hex2rgb = hex2rgb;
-const hextorgb = exports.hextorgb = hex2rgb;
+export var hextorgb = hex2rgb;
 
 /**
  * Parses a URL string into its components.
@@ -211,11 +211,11 @@ const hextorgb = exports.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`).
  */
-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]) {
@@ -242,14 +242,14 @@ const parse_url = function (str) {
  * addUrlParam('https://example.com', { key1: 'value1', key2: 'value2' });
  * // Returns: 'https://example.com?key1=value1&key2=value2'
  */
-exports.parse_url = parse_url;
-const addUrlParam = function (url, param, value = null) {
-  if ((0, _is.isPlainObject)(param)) {
-    (0, _traversal.each)(param, (key, val) => {
-      url = addUrlParam(url, key, val);
+var _addUrlParam = function addUrlParam(url, param) {
+  var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  if (isPlainObject(param)) {
+    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) {
@@ -261,9 +261,9 @@ 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;
@@ -282,149 +282,146 @@ const addUrlParam = function (url, param, value = null) {
   }
   return url;
 };
-exports.addUrlParam = addUrlParam;
-const decodeHtml = function (str) {
-  if (!(0, _is.isString)(str)) return '';
+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, "'");
 };
-exports.decodeHtml = decodeHtml;
-const htmlquotes = function (str) {
-  if (!(0, _is.isString)(str)) return '';
+export var htmlquotes = function htmlquotes(str) {
+  if (!isString(str)) return '';
   return str.replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 };
-exports.htmlquotes = htmlquotes;
-const htmlsimplequotes = function (str) {
-  if (!(0, _is.isString)(str)) return '';
+export var htmlsimplequotes = function htmlsimplequotes(str) {
+  if (!isString(str)) return '';
   return str.replace(/'/g, "&#039;");
 };
-exports.htmlsimplequotes = htmlsimplequotes;
-const repeat = function (str, n) {
-  if (!(0, _is.isString)(str) || !(0, _is.isFloat)(n)) return '';
+export var repeat = function repeat(str, n) {
+  if (!isString(str) || !isFloat(n)) return '';
   return new Array(Math.floor(n) + 1).join(str);
 };
-exports.repeat = repeat;
-const stripTags = function (str, tag) {
-  if ((0, _is.isString)(tag)) {
-    const rStripTags = new RegExp(`<${tag}[^>]*>(.*?)</${tag}>|<${tag}[^>]*\/>`, 'ig');
+export var stripTags = function stripTags(str, tag) {
+  if (isString(tag)) {
+    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, "");
 };
-exports.stripTags = stripTags;
-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
  */
-exports.toUrl = toUrl;
-const escapeRegex = function (str) {
+export var escapeRegex = function escapeRegex(str) {
   return str.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&").replace(/[\n\t]/g, " ");
 };
-exports.escapeRegex = escapeRegex;
-const camelCase = function (str) {
-  (0, _traversal.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();
+  });
 };
-exports.camelCase = camelCase;
-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) {
-    (0, _traversal.each)(args, (i, arg) => {
-      if ((0, _is.isString)(arg)) {
-        const o = {};
+    each(args, function (i, arg) {
+      if (isString(arg)) {
+        var o = {};
         o[i] = arg;
         arg = o;
       }
-      (0, _traversal.each)(arg, (placeholder, replacement) => {
-        str = str.replace(new RegExp('\\{' + placeholder + '\\}', 'gm'), match => (0, _is.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;
 };
-exports.format = format;
-const f = exports.f = format;
+export var f = format;
 
 /**
  * @see https://stackoverflow.com/questions/7627000/javascript-convert-string-to-safe-class-name-for-css
  */
-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);
   });
 };
-exports.toCssClassName = toCssClassName;
-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 (!(0, _is.isArray)(req)) {
+  if (!isArray(req)) {
     req = [req];
   }
-  (0, _traversal.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';
-  (0, _traversal.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>');
 };
-exports.hilite = hilite;
-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;
     i++;
   } while (bytes > 999);
-  if (!(0, _is.isInteger)(bytes)) {
+  if (!isInteger(bytes)) {
     decimals = 1;
   }
-  const units = (0, _traversal.map)(['k', 'M', 'G', 'T', 'P', 'E'], (i, prefix) => {
-    return prefix + (0, _i18n.translate)('unitByte');
+  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];
 };
-exports.formatSize = formatSize;
-const compareMixAlphaDigits = (a, b) => {
+export var compareMixAlphaDigits = function compareMixAlphaDigits(a, b) {
   if (a === b) return 0;
-  if ((0, _is.isInteger)(a) && (0, _is.isInteger)(b)) {
+  if (isInteger(a) && isInteger(b)) {
     return Math.sign(a - b);
   }
-  let startEq = '';
-  for (let i = 0; i < Math.min(a.length, b.length); i++) {
-    if (a.charAt(i) === b.charAt(i) && !(0, _is.isInteger)(a)) {
+  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 {
       break;
@@ -432,9 +429,9 @@ const compareMixAlphaDigits = (a, b) => {
   }
   a = a.slice(startEq.length);
   b = b.slice(startEq.length);
-  let nbA = '';
-  let idxDigitA = null;
-  (0, _traversal.each)(a, (i, c) => {
+  var nbA = '';
+  var idxDigitA = null;
+  each(a, function (i, c) {
     if (!nbA) {
       idxDigitA = i;
       if (c >= '0' && c <= '9') {
@@ -448,9 +445,9 @@ const compareMixAlphaDigits = (a, b) => {
       return false;
     }
   });
-  let nbB = '';
-  let idxDigitB = null;
-  (0, _traversal.each)(b, (i, c) => {
+  var nbB = '';
+  var idxDigitB = null;
+  each(b, function (i, c) {
     if (!nbB) {
       idxDigitB = i;
       if (c >= '0' && c <= '9') {
@@ -470,5 +467,4 @@ const compareMixAlphaDigits = (a, b) => {
     }
   }
   return a > b ? 1 : -1;
-};
-exports.compareMixAlphaDigits = compareMixAlphaDigits;
+};

package/dist/cjs/stringPrototype.js

@@ -1,16 +1,16 @@
-"use strict";
-
-var _traversal = require("./traversal.js");
-var stringFunctions = _interopRequireWildcard(require("./string.js"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-(0, _traversal.each)(Object.keys(stringFunctions), (i, name) => {
-  const f = stringFunctions[name],
+import { each } from "./traversal.js";
+import * as stringFunctions from "./string.js";
+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));
   };
 });