@webalternatif/js-core 1.1.0 → 1.1.2

package/dist/esm/string.js

@@ -1,51 +1,36 @@
-"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') {
+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);
 };
-exports.trim = trim;
-const ltrim = function (str, char = '\\s') {
+export const ltrim = function (str, char = '\\s') {
   return str.replace(new RegExp(`^${char}+`, 'g'), '');
 };
-exports.ltrim = ltrim;
-const rtrim = function (str, char = '\\s') {
+export const rtrim = function (str, char = '\\s') {
   return str.replace(new RegExp(`${char}+$`, 'g'), '');
 };
-exports.rtrim = rtrim;
-const stripMultipleSpaces = function (str) {
+export const stripMultipleSpaces = function (str) {
   return str.trim().replace(/ +/g, ' ');
 };
-exports.stripMultipleSpaces = stripMultipleSpaces;
-const noAccent = function (str) {
+export const noAccent = function (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 const br2nl = function (str) {
   return str.split(/<br\s*\/*>/).join('\n');
 };
-exports.br2nl = br2nl;
-const nl2br = function (str) {
+export const nl2br = function (str) {
   return str.split('\n').join('<br>');
 };
-exports.nl2br = nl2br;
-const ucfirst = function (str) {
+export const ucfirst = function (str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
-exports.ucfirst = ucfirst;
-const lcfirst = function (str) {
+export const lcfirst = function (str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 };
-exports.lcfirst = lcfirst;
-const insertTag = function (str, tag, position = 0, length = 0) {
+export const insertTag = function (str, tag, position = 0, length = 0) {
   let startTag = `<${tag}>`;
   let endTag = `</${tag}>`;
   if (['br', 'hr', 'img', 'link', 'input'].includes(tag)) {
@@ -54,8 +39,7 @@ const insertTag = function (str, tag, position = 0, length = 0) {
   }
   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) {
+export const substringIndex = function (str, delimiter, index) {
   let input = str + '',
     arr = input.split(delimiter);
   if (index > 0) {
@@ -65,8 +49,7 @@ const substringIndex = function (str, delimiter, index) {
   }
   return arr.join(delimiter);
 };
-exports.substringIndex = substringIndex;
-const insert = (str, ins, n) => {
+export const insert = (str, ins, n) => {
   if (n >= str.length) {
     return str;
   }
@@ -77,17 +60,15 @@ const insert = (str, ins, n) => {
     return newStr + char;
   }, '');
 };
-exports.insert = insert;
-const reverse = function (str) {
+export const reverse = function (str) {
   let res = [];
   for (let 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 const thousandSeparator = function (value, separator = '.', pointDecimal = '.') {
+  if (isUndefined(value) || null === value) {
     return value;
   }
   value = (value + '').replace(',', '.');
@@ -98,10 +79,9 @@ const thousandSeparator = function (value, separator = '.', pointDecimal = '.')
   }
   return (value + '').replace('.', pointDecimal);
 };
-exports.thousandSeparator = thousandSeparator;
-const numberFormat = function (number, decimals = 2, forceCentimes = false, thousandSep = '', pointDecimal = '.') {
+export const numberFormat = function (number, decimals = 2, forceCentimes = false, thousandSep = '', pointDecimal = '.') {
   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);
   }
@@ -119,8 +99,7 @@ const numberFormat = function (number, decimals = 2, forceCentimes = false, thou
   }
   return thousandSeparator(number.slice(0, pos + 1 + decimals), thousandSep, pointDecimal);
 };
-exports.numberFormat = numberFormat;
-const toPrice = exports.toPrice = numberFormat;
+export const toPrice = numberFormat;
 
 /**
  * Pads a string to a specified length with a specified string and padding type
@@ -131,8 +110,8 @@ 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 const pad = function (str, pad_length, pad_str = ' ', pad_type = 'left') {
+  if (isUndefined(pad_length) || str.length >= pad_length || !inArray(pad_type, ['left', 'right'])) {
     return str;
   }
   if (pad_type === 'left') {
@@ -158,16 +137,14 @@ 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)) {
+export const rgb2hex = function (r, g, b) {
+  if (isArray(r)) {
     return rgb2hex(...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 const rgbtohex = rgb2hex;
 
 /**
  * Converts a hexadecimal color to RGB values.
@@ -175,21 +152,20 @@ 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 const hex2rgb = function (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), (i, h) => h + '' + h).join('');
   }
   for (let 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(','), (i, h) => hex2dec(h));
 };
-exports.hex2rgb = hex2rgb;
-const hextorgb = exports.hextorgb = hex2rgb;
+export const hextorgb = hex2rgb;
 
 /**
  * Parses a URL string into its components.
@@ -211,7 +187,7 @@ 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) {
+export const parse_url = function (str) {
   const key = ['source', 'scheme', 'authority', 'userInfo', 'user', 'pass', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'fragment'],
     parser = /^(?:([^:\/?#]+):)?(?:\/\/()(?:(?:()(?:([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?()(?:(()(?:(?:[^?#\/]*\/)*)()(?:[^?#]*))(?:\?([^#]*))?(?:#(.*))?)/;
   const m = parser.exec(str);
@@ -242,10 +218,9 @@ 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) => {
+export const addUrlParam = function (url, param, value = null) {
+  if (isPlainObject(param)) {
+    each(param, (key, val) => {
       url = addUrlParam(url, key, val);
     });
   } else {
@@ -282,95 +257,84 @@ const addUrlParam = function (url, param, value = null) {
   }
   return url;
 };
-exports.addUrlParam = addUrlParam;
-const decodeHtml = function (str) {
-  if (!(0, _is.isString)(str)) return '';
+export const decodeHtml = function (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 const htmlquotes = function (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 const htmlsimplequotes = function (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 const repeat = function (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)) {
+export const stripTags = function (str, tag) {
+  if (isString(tag)) {
     const rStripTags = new RegExp(`<${tag}[^>]*>(.*?)</${tag}>|<${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 const toUrl = function (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 const escapeRegex = function (str) {
   return str.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&").replace(/[\n\t]/g, " ");
 };
-exports.escapeRegex = escapeRegex;
-const camelCase = function (str) {
-  (0, _traversal.foreach)('-_', char => {
+export const camelCase = function (str) {
+  foreach('-_', char => {
     str = trim(str, char).replace(new RegExp(`${char}+`, 'g'), char);
   });
   str = trim(str).replace(/\s+/g, '-');
   return str.toLowerCase().replace(/[_-](\w)/g, (match, p1) => p1.toUpperCase());
 };
-exports.camelCase = camelCase;
-const format = function (str, ...args) {
+export const format = function (str, ...args) {
   if (args.length) {
-    (0, _traversal.each)(args, (i, arg) => {
-      if ((0, _is.isString)(arg)) {
+    each(args, (i, arg) => {
+      if (isString(arg)) {
         const 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, (placeholder, replacement) => {
+        str = str.replace(new RegExp('\\{' + placeholder + '\\}', 'gm'), match => isUndefined(replacement) ? match : replacement);
       });
     });
   }
   return str;
 };
-exports.format = format;
-const f = exports.f = format;
+export const f = format;
 
 /**
  * @see https://stackoverflow.com/questions/7627000/javascript-convert-string-to-safe-class-name-for-css
  */
-const toCssClassName = function (str) {
+export const toCssClassName = function (str) {
   return str.replace(/[^a-z0-9_-]/ig, s => {
     const 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 const hilite = function (str, req, tag = 'strong') {
   str = decodeHtml(str);
   let str_folded = noAccent(str).toLowerCase().replace(/[\[\]]+/g, '');
   let q_folded,
     re,
     hilite_hints = '';
-  if (!(0, _is.isArray)(req)) {
+  if (!isArray(req)) {
     req = [req];
   }
-  (0, _traversal.each)(req, (i, q) => {
+  each(req, (i, q) => {
     if (q.length) {
       q = decodeHtml(q);
       q_folded = noAccent(q).toLowerCase().replace(/[\[\]]+/g, '');
@@ -385,7 +349,7 @@ const hilite = function (str, req, tag = 'strong') {
   let spos = 0;
   let highlighted = '';
   let dirHook = 'end';
-  (0, _traversal.each)(hilite_hints, (i, hint) => {
+  each(hilite_hints, (i, hint) => {
     const c = str.charAt(spos);
     if (hint === '[' && dirHook === 'end') {
       highlighted += `<${tag}>`;
@@ -400,31 +364,29 @@ const hilite = function (str, req, tag = 'strong') {
   });
   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>');
 };
-exports.hilite = hilite;
-const formatSize = function (bytes, decimalPoint = ',') {
+export const formatSize = function (bytes, decimalPoint = ',') {
   let 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');
+  const units = map(['k', 'M', 'G', 'T', 'P', 'E'], (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 const 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)) {
+    if (a.charAt(i) === b.charAt(i) && !isInteger(a)) {
       startEq += a.charAt(i);
     } else {
       break;
@@ -434,7 +396,7 @@ const compareMixAlphaDigits = (a, b) => {
   b = b.slice(startEq.length);
   let nbA = '';
   let idxDigitA = null;
-  (0, _traversal.each)(a, (i, c) => {
+  each(a, (i, c) => {
     if (!nbA) {
       idxDigitA = i;
       if (c >= '0' && c <= '9') {
@@ -450,7 +412,7 @@ const compareMixAlphaDigits = (a, b) => {
   });
   let nbB = '';
   let idxDigitB = null;
-  (0, _traversal.each)(b, (i, c) => {
+  each(b, (i, c) => {
     if (!nbB) {
       idxDigitB = i;
       if (c >= '0' && c <= '9') {
@@ -470,5 +432,4 @@ const compareMixAlphaDigits = (a, b) => {
     }
   }
   return a > b ? 1 : -1;
-};
-exports.compareMixAlphaDigits = compareMixAlphaDigits;
+};

package/dist/esm/stringPrototype.js

@@ -1,9 +1,6 @@
-"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) => {
+import { each } from "./traversal.js";
+import * as stringFunctions from "./string.js";
+each(Object.keys(stringFunctions), (i, name) => {
   const f = stringFunctions[name],
     p = String.prototype;
   const origSF = p[name];

package/dist/esm/traversal.js

@@ -1,77 +1,142 @@
-"use strict";
+import { isArray, isArrayLike, isBoolean, isObject, isPlainObject, isString, isUndefined } from "./is.js";
+import { isWindow } from "./dom.js";
+import { sizeOf } from "./utils.js";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.reduce = exports.merge = exports.map = exports.foreach = exports.extend = exports.each = exports.clone = void 0;
-var _is = require("./is.js");
-var _dom = require("./dom.js");
-var _utils = require("./utils.js");
-const each = function (o, callback, context) {
-  const oToString = Object.prototype.toString.call(o);
-  if (oToString === '[object Set]') {
-    o = [...o];
-  } else if (oToString === '[object Map]') {
-    o = Object.fromEntries(o);
-  }
-  if ((0, _is.isArray)(o)) {
-    for (let i = 0; i < o.length; i++) if (false === callback.call(context || o[i], i, o[i], o, i)) return;
-  } else if ((0, _is.isObject)(o)) {
+/**
+ * @template T
+ * @typedef {Array<T> | Set<T> | Map<any, T> | Object<string, T> | string} Collection
+ */
+
+/**
+ * Iterates over Arrays, Strings, Maps, Sets and plain Objects.
+ *
+ * The callback receives:
+ *   (keyOrIndex, value, o, index)
+ *
+ * If the callback returns `false`, the iteration stops.
+ *
+ * @template T
+ * @param {Collection<T>} o
+ * @param {(key: number|string, value: T, o: Collection<T>, index: number) => (void|boolean)} callback
+ * @param {any} [context] Optional "this" binding for the callback
+ * @returns {typeof o} Returns the original input
+ */
+export const each = function (o, callback, context) {
+  if (isPlainObject(o)) {
     let index = -1;
-    for (let i in o) if (o.hasOwnProperty(i) && false === callback.call(context || o[i], i, o[i], o, ++index)) return;
-  } else if ((0, _is.isString)(o)) {
+    for (let i in o) if (o.hasOwnProperty(i) && false === callback.call(context ?? o[i], i, o[i], o, ++index)) return;
+  } else if (isString(o)) {
     const arr = o.split('');
-    for (let i = 0; i < arr.length; i++) if (false === callback.call(context || arr[i], i, arr[i], o, i)) return;
+    for (let i = 0; i < arr.length; i++) if (false === callback.call(context ?? arr[i], i, arr[i], o, i)) return;
+    return o;
+  } else if (o instanceof Map) {
+    let index = 0;
+    for (const [key, value] of o.entries()) {
+      if (false === callback.call(context ?? value, key, value, o, index++)) return;
+    }
+  } else if (o instanceof Set) {
+    let index = 0;
+    for (const value of o.values()) {
+      if (false === callback.call(context ?? value, index, value, o, index)) return;
+      index++;
+    }
+  } else if (isArrayLike(o)) {
+    o = Array.from(o);
+    for (let i = 0; i < o.length; i++) if (false === callback.call(context || o[i], i, o[i], o, i)) return;
   }
   return o;
 };
-exports.each = each;
-const foreach = function (o, callback, context) {
+
+/**
+ * Same as each except that key and value are reversed in callback
+ *
+ * The callback receives:
+ *   (value, keyOrIndex, o, index)
+ *
+ * @template T
+ * @param {Collection<T>} o
+ * @param {(value: T, key: number|string, o: Collection<T>, index: number) => (void|boolean)} callback
+ * @param {any} [context] Optional "this" binding for the callback
+ * @returns {typeof o} Returns the original input
+ */
+export const foreach = function (o, callback, context) {
   return each(o, (key, value, o, index) => callback.apply(context || value, [value, key, o, index]), context);
 };
-exports.foreach = foreach;
-const map = function (o, callback, context) {
+
+/**
+ * Iterates over Arrays, Strings, Maps, Sets and plain Objects.
+ * Returns an array from the callback results.
+ * Values strictly equal to `null` are skipped.
+ * Values strictly equal to `false` stops the iteration.
+ *
+ * The callback receives:
+ *   (keyOrIndex, value, o, index)
+ *
+ * @template T,R
+ * @param {Collection<T>} o
+ * @param {(key: number|string, value: T, o: Collection<T>, index: number) => (R|null|false)} callback
+ * @param {any} [context] Optional "this" binding for the callback
+ * @returns {Array} Returns the resulted array
+ */
+export const map = function (o, callback, context) {
   let results = [];
   each(o, function (index, value, o, i) {
     const response = callback.call(context, index, value, o, i);
-    if (response !== null) {
-      results.push(response);
-    }
+    if (false === response) return false;
+    if (null !== response) results.push(response);
   });
   return results;
 };
-exports.map = map;
-const reduce = function (o, callback, initialValue) {
-  const isInitialValueDefined = !(0, _is.isUndefined)(initialValue);
-  if (!(0, _utils.sizeOf)(o) && !isInitialValueDefined) {
+
+/**
+ * Reduces a collection to a single value
+ *
+ * The reducer receives:
+ *    (accumulator, value, index, source)
+ *
+ * @template T,R
+ * @param {Collection<T>} o
+ * @param {(accumulator: R|T, value: T, key: any, index: number, o: Collection<T>) => R} callback
+ * @param {R} [initialValue] la valeur initiale
+ * @returns {R} Returns the accumulated value
+ */
+export const reduce = function (o, callback, initialValue) {
+  const isInitialValueDefined = !isUndefined(initialValue);
+  if (!sizeOf(o) && !isInitialValueDefined) {
     throw new Error('Nothing to reduce and no initial value');
   }
-  let accumulator = !isInitialValueDefined ? map(o, (i, v) => i === 0 ? v : null)[0] : initialValue;
-  each(o, (i, v) => {
-    if (i === 0 && !isInitialValueDefined) {
-      return true;
-    }
-    accumulator = callback(accumulator, v, i, o);
+  let accumulator = !isInitialValueDefined ? map(o, (key, v, o, i) => i === 0 ? v : null)[0] : initialValue;
+  each(o, (key, v, o, i) => {
+    if (i === 0 && !isInitialValueDefined) return;
+    accumulator = callback(accumulator, v, key, i, o);
   });
   return accumulator;
 };
-exports.reduce = reduce;
-const extend = function (...args) {
+
+/**
+ * Creates a shallow or deep copy of one or more objects or arrays
+ * If the first argument is `true`, nested plain objects are merged recursively.
+ *
+ * @template T
+ * @param {...(boolean|T)} args
+ * @returns {T} A copy of the merged result
+ */
+export const extend = function (...args) {
   let deep = false;
-  if ((0, _is.isBoolean)(args[0])) {
+  if (isBoolean(args[0])) {
     deep = args.shift();
   }
-  if (args.length < 2 || (0, _is.isUndefined)(args[0]) || null === args[0]) {
+  if (args.length < 2 || isUndefined(args[0]) || null === args[0]) {
     return args[0];
   }
   let dest = args[0];
-  if (!(0, _is.isObject)(dest)) {
+  if (!isObject(dest)) {
     args[0] = dest = {};
   }
-  each(args.slice(1), (i, src) => {
-    if ((0, _is.isObject)(src)) {
-      for (let name in src) {
-        if (deep && (0, _is.isPlainObject)(src[name])) {
+  foreach(args.slice(1), src => {
+    if (isObject(src)) {
+      for (const name in src) {
+        if (deep && isPlainObject(src[name])) {
           dest[name] = extend(true, {}, dest[name], src[name]);
         } else {
           dest[name] = src[name];
@@ -81,23 +146,39 @@ const extend = function (...args) {
   });
   return dest;
 };
-exports.extend = extend;
-const clone = function (o) {
-  if (!(0, _is.isObject)(o) && !(0, _is.isArray)(o) || (0, _dom.isWindow)(o)) {
+
+/**
+ * Creates a deep copy of an Object or Array
+ *
+ * @template T
+ * @param {T} o
+ * @returns {T} The copy of o
+ */
+export const clone = function (o) {
+  if (!isObject(o) && !isArray(o) || isWindow(o)) {
     return o;
   }
-  const c = (0, _is.isObject)(o) ? {} : [];
-  each(o, (i, value) => {
-    if ((0, _is.isObject)(value)) {
-      c[i] = clone(value);
+  const c = isObject(o) ? {} : [];
+  each(o, (key, value) => {
+    if (isObject(value)) {
+      c[key] = clone(value);
     } else {
-      c[i] = value;
+      c[key] = value;
     }
   });
   return c;
 };
-exports.clone = clone;
-const merge = function (first, second = [], ...args) {
+
+/**
+ * Merge multiple collections into a single array
+ *
+ * @template T
+ * @param {Collection<T>} first
+ * @param {Collection<T>} [second]
+ * @param {...Collection<T>} args Remaining collections to merge
+ * @returns {Array<T>} the resulted merged array
+ */
+export const merge = function (first, second = [], ...args) {
   const result = map(first, (i, elem) => elem);
   each(second, function (i, elem) {
     result.push(elem);
@@ -106,5 +187,4 @@ const merge = function (first, second = [], ...args) {
     return merge(result, ...args);
   }
   return result;
-};
-exports.merge = merge;
+};