@webalternatif/js-core 1.0.0

package/dist/cjs/string.js

@@ -0,0 +1,474 @@
+"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) {
+  return str.trim().replace(/ +/g, ' ');
+};
+exports.stripMultipleSpaces = stripMultipleSpaces;
+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) {
+  return str.split(/<br\s*\/*>/).join('\n');
+};
+exports.br2nl = br2nl;
+const nl2br = function (str) {
+  return str.split('\n').join('<br>');
+};
+exports.nl2br = nl2br;
+const ucfirst = function (str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+exports.ucfirst = ucfirst;
+const lcfirst = function (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}>`;
+  if (['br', 'hr', 'img', 'link', 'input'].includes(tag)) {
+    startTag = `<${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 + '',
+    arr = input.split(delimiter);
+  if (index > 0) {
+    arr.splice(index, arr.length - index);
+  } else if (index < 0) {
+    arr.splice(0, arr.length + index);
+  }
+  return arr.join(delimiter);
+};
+exports.substringIndex = substringIndex;
+const insert = (str, ins, n) => {
+  if (n >= str.length) {
+    return str;
+  }
+  return [...str].reduce((newStr, char, index) => {
+    if (index > 0 && index % n === 0) {
+      return newStr + ins + char;
+    }
+    return newStr + char;
+  }, '');
+};
+exports.insert = insert;
+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) {
+    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));
+    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 = '.') {
+  number = number ? number + '' : '0';
+  number = (0, _math.round)(parseFloat(number.replace(',', '.')), decimals) + '';
+  if (decimals === 0) {
+    return thousandSeparator(number, thousandSep, pointDecimal);
+  }
+  const 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;
+  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;
+
+/**
+ * Pads a string to a specified length with a specified string and padding type
+ *
+ * @param {string} str
+ * @param {number} pad_length
+ * @param {string} [pad_str]
+ * @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'])) {
+    return str;
+  }
+  if (pad_type === 'left') {
+    return pad_str.repeat(Math.ceil(pad_length / pad_str.length)).slice(0, pad_length - str.length) + str;
+  }
+  return str + pad_str.repeat(Math.ceil(pad_length / pad_str.length)).slice(0, pad_length - str.length);
+};
+
+/**
+ * Converts RGB values to a hexadecimal color string.
+ *
+ * @param {number|number[]} r - Either an array representing a RGB color (e.g. [255, 0, 0]) or the red component as a
+ *                              number (0-255).
+ * @param {number} [g] - The green component (0-255). Required if `r` is a number.
+ * @param {number} [b] - The blue component (0-255). Required if `r` is a number.
+ * @returns {string} The hexadecimal color string (e.g., 'FF0000').
+ *
+ * @example
+ * // Using separate RGB components
+ * rgb2hex(255, 0, 0); // Returns 'FF0000'
+ *
+ * @example
+ * // 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);
+  }
+  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('');
+};
+exports.rgb2hex = rgb2hex;
+const rgbtohex = exports.rgbtohex = rgb2hex;
+
+/**
+ * Converts a hexadecimal color to RGB values.
+ *
+ * @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 [];
+  hex = hex.slice(-6).toUpperCase();
+  if (hex.length < 6) {
+    hex = (0, _traversal.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));
+};
+exports.hex2rgb = hex2rgb;
+const hextorgb = exports.hextorgb = hex2rgb;
+
+/**
+ * Parses a URL string into its components.
+ *
+ * @param {string} str - The URL string to be parsed.
+ * @returns {Object} An object containing the parsed components of the URL.
+ *
+ * @property {string} [scheme] - The scheme (protocol) of the URL (e.g., `http`, `https`).
+ * @property {string} [authority] - The authority part of the URL.
+ * @property {string} [userInfo] - The user information (e.g., `user:pass`).
+ * @property {string} [user] - The username from the user information.
+ * @property {string} [pass] - The password from the user information.
+ * @property {string} [host] - The host of the URL (e.g., `example.com`).
+ * @property {string} [port] - The port of the URL (e.g., `8080`).
+ * @property {string} [relative] - The relative URL.
+ * @property {string} [path] - The path of the URL (e.g., `/path/to/resource`).
+ * @property {string} [directory] - The directory of the URL path.
+ * @property {string} [file] - The file name from the path, if applicable.
+ * @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'],
+    parser = /^(?:([^:\/?#]+):)?(?:\/\/()(?:(?:()(?:([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?()(?:(()(?:(?:[^?#\/]*\/)*)()(?:[^?#]*))(?:\?([^#]*))?(?:#(.*))?)/;
+  const m = parser.exec(str);
+  let uri = {},
+    i = 14;
+  while (i--) {
+    if (m[i]) {
+      uri[key[i]] = m[i];
+    }
+  }
+  delete uri.source;
+  return uri;
+};
+
+/**
+ * Adds or updates one or more query parameters to a given URL.
+ *
+ * @param {string} url - The URL to which the parameters should be added.
+ * @param {string|Object} param - The key of the parameter to add, or an object containing multiple key-value pairs to add.
+ * @param {string|null} [value=null] - The value of the parameter to add. Ignored if `param` is an object.
+ * @returns {string} The updated URL with the new query parameters.
+ *
+ * @example <caption>Add a single parameter to a URL without a query string</caption>
+ * addUrlParam('https://example.com', 'key', 'value');
+ * // Returns: 'https://example.com?key=value'
+ *
+ * @example <caption>Add multiple parameters to a URL</caption>
+ * 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);
+    });
+  } else {
+    let parseUrl = parse_url(url),
+      pos,
+      hash = "";
+    if ((pos = url.indexOf("#")) > -1) {
+      hash = url.slice(pos);
+    }
+    if (hash) {
+      url = url.slice(0, url.lastIndexOf(hash));
+    }
+    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++) {
+        if (params[i].indexOf(param + "=") > -1) {
+          param_exists = true;
+          params[i] = param + "=" + value;
+          break;
+        }
+      }
+      if (false === param_exists) {
+        params.push(param + "=" + value);
+      }
+      if (parseUrl.scheme && parseUrl.host) {
+        url = parseUrl.scheme + '://' + parseUrl.host + (parseUrl.path || '') + "?" + params.join("&") + hash;
+      } else {
+        url = (parseUrl.host || '') + parseUrl.path + "?" + params.join("&") + hash;
+      }
+    }
+  }
+  return url;
+};
+exports.addUrlParam = addUrlParam;
+const decodeHtml = function (str) {
+  if (!(0, _is.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 '';
+  return str.replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+};
+exports.htmlquotes = htmlquotes;
+const htmlsimplequotes = function (str) {
+  if (!(0, _is.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 '';
+  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');
+    while (rStripTags.test(str)) str = str.replace(rStripTags, '$1');
+    return str;
+  }
+  return str.replace(/(<([^>]+)>)/ig, "");
+};
+exports.stripTags = stripTags;
+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) {
+  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);
+  });
+  str = trim(str).replace(/\s+/g, '-');
+  return str.toLowerCase().replace(/[_-](\w)/g, (match, p1) => p1.toUpperCase());
+};
+exports.camelCase = camelCase;
+const format = function (str, ...args) {
+  if (args.length) {
+    (0, _traversal.each)(args, (i, arg) => {
+      if ((0, _is.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);
+      });
+    });
+  }
+  return str;
+};
+exports.format = format;
+const f = exports.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);
+    if (c === 32) return '-';
+    return '__' + ('000' + c.toString(16)).slice(-4);
+  });
+};
+exports.toCssClassName = toCssClassName;
+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)) {
+    req = [req];
+  }
+  (0, _traversal.each)(req, (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}]`);
+      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);
+    if (hint === '[' && dirHook === 'end') {
+      highlighted += `<${tag}>`;
+      dirHook = 'start';
+    } else if (hint === ']' && dirHook === 'start') {
+      highlighted += `</${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>');
+};
+exports.hilite = hilite;
+const formatSize = function (bytes, decimalPoint = ',') {
+  let i = -1,
+    decimals = 0;
+  do {
+    bytes /= 1024;
+    i++;
+  } while (bytes > 999);
+  if (!(0, _is.isInteger)(bytes)) {
+    decimals = 1;
+  }
+  const units = (0, _traversal.map)(['k', 'M', 'G', 'T', 'P', 'E'], (i, prefix) => {
+    return prefix + (0, _i18n.translate)('unitByte');
+  });
+  return numberFormat(Math.max(bytes, 0), decimals, true, '', decimalPoint) + ' ' + units[i];
+};
+exports.formatSize = formatSize;
+const compareMixAlphaDigits = (a, b) => {
+  if (a === b) return 0;
+  if ((0, _is.isInteger)(a) && (0, _is.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)) {
+      startEq += a.charAt(i);
+    } else {
+      break;
+    }
+  }
+  a = a.slice(startEq.length);
+  b = b.slice(startEq.length);
+  let nbA = '';
+  let idxDigitA = null;
+  (0, _traversal.each)(a, (i, c) => {
+    if (!nbA) {
+      idxDigitA = i;
+      if (c >= '0' && c <= '9') {
+        nbA += c;
+      }
+    } else {
+      if (c >= '0' && c <= '9') {
+        nbA += c;
+        return true;
+      }
+      return false;
+    }
+  });
+  let nbB = '';
+  let idxDigitB = null;
+  (0, _traversal.each)(b, (i, c) => {
+    if (!nbB) {
+      idxDigitB = i;
+      if (c >= '0' && c <= '9') {
+        nbB += c;
+      }
+    } else {
+      if (c >= '0' && c <= '9') {
+        nbB += c;
+        return true;
+      }
+      return false;
+    }
+  });
+  if (nbA.length && nbB.length && idxDigitA === idxDigitB) {
+    if (a.substring(0, idxDigitA) === b.substring(0, idxDigitB)) {
+      return Math.sign(nbA - nbB);
+    }
+  }
+  return a > b ? 1 : -1;
+};
+exports.compareMixAlphaDigits = compareMixAlphaDigits;

package/dist/cjs/stringPrototype.js

@@ -0,0 +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],
+    p = String.prototype;
+  const origSF = p[name];
+  p[name] = function (...args) {
+    if (origSF && args.length === origSF.length) {
+      return origSF.apply(this, args);
+    }
+    return f(this, ...args);
+  };
+});

package/dist/cjs/traversal.js

@@ -0,0 +1,110 @@
+"use strict";
+
+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)) {
+    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)) {
+    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;
+  }
+  return o;
+};
+exports.each = each;
+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) {
+  let results = [];
+  each(o, function (index, value, o, i) {
+    const response = callback.call(context, index, value, o, i);
+    if (response !== null) {
+      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) {
+    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);
+  });
+  return accumulator;
+};
+exports.reduce = reduce;
+const extend = function (...args) {
+  let deep = false;
+  if ((0, _is.isBoolean)(args[0])) {
+    deep = args.shift();
+  }
+  if (args.length < 2 || (0, _is.isUndefined)(args[0]) || null === args[0]) {
+    return args[0];
+  }
+  let dest = args[0];
+  if (!(0, _is.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])) {
+          dest[name] = extend(true, {}, dest[name], src[name]);
+        } else {
+          dest[name] = src[name];
+        }
+      }
+    }
+  });
+  return dest;
+};
+exports.extend = extend;
+const clone = function (o) {
+  if (!(0, _is.isObject)(o) && !(0, _is.isArray)(o) || (0, _dom.isWindow)(o)) {
+    return o;
+  }
+  const c = (0, _is.isObject)(o) ? {} : [];
+  each(o, (i, value) => {
+    if ((0, _is.isObject)(value)) {
+      c[i] = clone(value);
+    } else {
+      c[i] = value;
+    }
+  });
+  return c;
+};
+exports.clone = clone;
+const merge = function (first, second = [], ...args) {
+  const result = map(first, (i, elem) => elem);
+  each(second, function (i, elem) {
+    result.push(elem);
+  });
+  if (args.length) {
+    return merge(result, ...args);
+  }
+  return result;
+};
+exports.merge = merge;