@webalternatif/js-core 1.1.1 → 1.1.3

package/dist/cjs/traversal.js

@@ -1,78 +1,177 @@
-"use strict";
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+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 _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, 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)) {
-    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;
+/**
+ * @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 var each = function each(o, callback, context) {
+  if (isPlainObject(o)) {
+    var index = -1;
+    for (var i in o) if (o.hasOwnProperty(i) && false === callback.call(context !== null && context !== void 0 ? context : o[i], i, o[i], o, ++index)) return;
+  } else if (isString(o)) {
+    var arr = o.split('');
+    for (var _i = 0; _i < arr.length; _i++) if (false === callback.call(context !== null && context !== void 0 ? context : arr[_i], _i, arr[_i], o, _i)) return;
+    return o;
+  } else if (o instanceof Map) {
+    var _index = 0;
+    var _iterator = _createForOfIteratorHelper(o.entries()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          key = _step$value[0],
+          value = _step$value[1];
+        if (false === callback.call(context !== null && context !== void 0 ? context : value, key, value, o, _index++)) return;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } else if (o instanceof Set) {
+    var _index2 = 0;
+    var _iterator2 = _createForOfIteratorHelper(o.values()),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _value = _step2.value;
+        if (false === callback.call(context !== null && context !== void 0 ? context : _value, _index2, _value, o, _index2)) return;
+        _index2++;
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  } else if (isArrayLike(o)) {
+    o = Array.from(o);
+    for (var _i2 = 0; _i2 < o.length; _i2++) if (false === callback.call(context || o[_i2], _i2, o[_i2], o, _i2)) 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);
+
+/**
+ * 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 var foreach = function foreach(o, callback, context) {
+  return each(o, function (key, value, o, index) {
+    return callback.apply(context || value, [value, key, o, index]);
+  }, context);
 };
-exports.foreach = foreach;
-const map = function (o, callback, context) {
-  let results = [];
+
+/**
+ * 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 var map = function map(o, callback, context) {
+  var results = [];
   each(o, function (index, value, o, i) {
-    const response = callback.call(context, index, value, o, i);
-    if (response !== null) {
-      results.push(response);
-    }
+    var response = callback.call(context, index, value, o, i);
+    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 var reduce = function reduce(o, callback, initialValue) {
+  var 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);
+  var accumulator = !isInitialValueDefined ? map(o, function (key, v, o, i) {
+    return i === 0 ? v : null;
+  })[0] : initialValue;
+  each(o, function (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) {
-  let deep = false;
-  if ((0, _is.isBoolean)(args[0])) {
+
+/**
+ * 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
+ */
+var _extend = function extend() {
+  var deep = false;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  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)) {
+  var dest = args[0];
+  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])) {
-          dest[name] = extend(true, {}, dest[name], src[name]);
+  foreach(args.slice(1), function (src) {
+    if (isObject(src)) {
+      for (var name in src) {
+        if (deep && isPlainObject(src[name])) {
+          dest[name] = _extend(true, {}, dest[name], src[name]);
         } else {
           dest[name] = src[name];
         }
@@ -81,30 +180,54 @@ 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 { _extend as extend };
+var _clone = function clone(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);
+  var c = isObject(o) ? {} : [];
+  each(o, function (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) {
-  const result = map(first, (i, elem) => elem);
+
+/**
+ * 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 { _clone as clone };
+var _merge = function merge(first) {
+  var second = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var result = map(first, function (i, elem) {
+    return elem;
+  });
   each(second, function (i, elem) {
     result.push(elem);
   });
+  for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+    args[_key2 - 2] = arguments[_key2];
+  }
   if (args.length) {
-    return merge(result, ...args);
+    return _merge.apply(void 0, [result].concat(args));
   }
   return result;
 };
-exports.merge = merge;
+export { _merge as merge };

package/dist/cjs/utils.js

@@ -1,35 +1,32 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.throttle = exports.strParseFloat = exports.sizeOf = exports.noop = exports.flatten = exports.equals = exports.debounce = void 0;
-var _traversal = require("./traversal.js");
-var _is = require("./is.js");
-const equals = function (o1, o2, seen = new WeakMap()) {
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { each, map } from "./traversal.js";
+import { isArray, isFunction, isObject, isUndefined } from "./is.js";
+var _equals = function equals(o1, o2) {
+  var seen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakMap();
   if (o1 === o2) return true;
-  if (typeof o1 !== typeof o2 || o1 == null || o2 == null) {
+  if (_typeof(o1) !== _typeof(o2) || o1 == null || o2 == null) {
     return false;
   }
-  if ((0, _is.isObject)(o1)) {
+  if (isObject(o1)) {
     if (seen.has(o1)) {
       return seen.get(o1) === o2;
     }
     seen.set(o1, o2);
-    const keys1 = Object.keys(o1),
+    var keys1 = Object.keys(o1),
       keys2 = Object.keys(o2);
     if (keys1.length !== keys2.length) {
       return false;
     }
-    return keys1.every(key => equals(o1[key], o2[key], seen));
+    return keys1.every(function (key) {
+      return _equals(o1[key], o2[key], seen);
+    });
   }
   return false;
 };
-exports.equals = equals;
-const noop = function () {};
-exports.noop = noop;
-const sizeOf = function (o) {
-  return (0, _traversal.map)(o, noop).length;
+export { _equals as equals };
+export var noop = function noop() {};
+export var sizeOf = function sizeOf(o) {
+  return map(o, noop).length;
 };
 
 /**
@@ -48,36 +45,43 @@ const sizeOf = function (o) {
  * console.log(result);
  * // Output: [1, 2, 3, 4]
  */
-exports.sizeOf = sizeOf;
-const flatten = function (o) {
-  if ((0, _is.isObject)(o) || (0, _is.isArray)(o)) {
-    return [].concat.apply([], (0, _traversal.map)(o, (i, val) => flatten(val)));
+var _flatten = function flatten(o) {
+  if (isObject(o) || isArray(o)) {
+    return [].concat.apply([], map(o, function (i, val) {
+      return _flatten(val);
+    }));
   }
   return o;
 };
-exports.flatten = flatten;
-const strParseFloat = function (val) {
+export { _flatten as flatten };
+export var strParseFloat = function strParseFloat(val) {
   if (!val) return 0;
   return parseFloat((val + '').replace(/\s/g, '').replace(',', '.'));
 };
-exports.strParseFloat = strParseFloat;
-const throttle = function (func, wait, leading = true, trailing = true, context = null) {
-  let timeout = null;
-  let lastCall = 0;
-  return function (...args) {
-    const now = Date.now();
+export var throttle = function throttle(func, wait) {
+  var leading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var trailing = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var context = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+  var timeout = null;
+  var lastCall = 0;
+  return function () {
+    var _this = this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var now = Date.now();
     if (!lastCall && !leading) {
       lastCall = now;
     }
-    const remaining = wait - (now - lastCall);
+    var remaining = wait - (now - lastCall);
     if (remaining <= 0 || remaining > wait) {
       lastCall = now;
       func.apply(context || this, args);
     } else if (!timeout && trailing) {
-      timeout = setTimeout(() => {
+      timeout = setTimeout(function () {
         timeout = null;
         lastCall = leading ? Date.now() : 0;
-        func.apply(context || this, args);
+        func.apply(context || _this, args);
       }, remaining);
     }
   };
@@ -93,12 +97,17 @@ const throttle = function (func, wait, leading = true, trailing = true, context
  * @param {Object} [context=null] - The context to bind to `func`.
  * @returns {Function} The debounced function.
  */
-exports.throttle = throttle;
-const debounce = function (func, wait, immediate = false, context = null) {
-  let timeout = null;
-  let lastCall = 0;
-  return function (...args) {
-    const now = Date.now();
+export var debounce = function debounce(func, wait) {
+  var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var context = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  var timeout = null;
+  var lastCall = 0;
+  return function () {
+    var _this2 = this;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    var now = Date.now();
     if (immediate) {
       if (!lastCall) {
         lastCall = now;
@@ -107,12 +116,11 @@ const debounce = function (func, wait, immediate = false, context = null) {
     }
     clearTimeout(timeout);
     timeout = null;
-    timeout = setTimeout(() => {
+    timeout = setTimeout(function () {
       lastCall = now;
       clearTimeout(timeout);
       timeout = null;
-      func.apply(context || this, args);
+      func.apply(context || _this2, args);
     }, wait);
   };
-};
-exports.debounce = debounce;
+};

package/dist/esm/array.js

@@ -1,13 +1,8 @@
-"use strict";
+import { each } from "./traversal.js";
+import { isArray, isInteger, isObject, isString, isUndefined } from "./is.js";
+import { round } from "./math.js";
+import { equals } from "./utils.js";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.range = exports.indexOf = exports.inArray = exports.compareArray = exports.array_unique = exports.array_diff = exports.arrayUnique = exports.arrayDiff = void 0;
-var _traversal = require("./traversal.js");
-var _is = require("./is.js");
-var _math = require("./math.js");
-var _utils = require("./utils.js");
 /**
  * Checks if a value exists in an array or an object
  *
@@ -29,9 +24,11 @@ var _utils = require("./utils.js");
  * inArray(5, [1, 2, 3])
  * // → false
  */
-const inArray = function (value, arr, index = 0, strict = false) {
-  let ret = false;
-  (0, _traversal.each)(arr, (i, val) => {
+export var inArray = function inArray(value, arr) {
+  var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var strict = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var ret = false;
+  each(arr, function (i, val) {
     if (i >= index) {
       if (strict) {
         if (val === value) {
@@ -39,11 +36,11 @@ const inArray = function (value, arr, index = 0, strict = false) {
           return false;
         }
       } else {
-        if ((0, _is.isObject)(value) && (0, _is.isObject)(val)) {
-          ret = (0, _utils.equals)(val, value);
+        if (isObject(value) && isObject(val)) {
+          ret = equals(val, value);
           return false;
-        } else if ((0, _is.isArray)(value) && (0, _is.isObject)(val)) {
-          ret = compareArray(val, value);
+        } else if (isArray(value) && isObject(val)) {
+          ret = _compareArray(val, value);
           return false;
         } else if (val == value) {
           ret = true;
@@ -54,8 +51,8 @@ const inArray = function (value, arr, index = 0, strict = false) {
   });
   return ret;
 };
-exports.inArray = inArray;
-const indexOf = function (arr, elt, from = 0) {
+export var indexOf = function indexOf(arr, elt) {
+  var from = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   from = from < 0 ? Math.ceil(from) + arr.length : Math.floor(from);
   for (; from < arr.length; from++) {
     if (from in arr && arr[from] === elt) {
@@ -64,17 +61,16 @@ const indexOf = function (arr, elt, from = 0) {
   }
   return -1;
 };
-exports.indexOf = indexOf;
-const compareArray = function (a1, a2) {
+var _compareArray = function compareArray(a1, a2) {
   if (a1.length !== a2.length) {
     return false;
   } else {
-    for (let i = 0; i < a1.length; i++) {
-      if ((0, _is.isArray)(a1[i])) {
-        if (!(0, _is.isArray)(a2[i])) {
+    for (var i = 0; i < a1.length; i++) {
+      if (isArray(a1[i])) {
+        if (!isArray(a2[i])) {
           return false;
         }
-        return compareArray(a1[i], a2[i]);
+        return _compareArray(a1[i], a2[i]);
       } else if (a1[i] !== a2[i]) {
         return false;
       }
@@ -82,35 +78,39 @@ const compareArray = function (a1, a2) {
   }
   return true;
 };
-exports.compareArray = compareArray;
-const arrayUnique = function (arr) {
-  return arr.filter((el, index, arr) => index === indexOf(arr, el));
+export { _compareArray as compareArray };
+export var arrayUnique = function arrayUnique(arr) {
+  return arr.filter(function (el, index, arr) {
+    return index === indexOf(arr, el);
+  });
 };
-exports.arrayUnique = arrayUnique;
-const array_unique = exports.array_unique = arrayUnique;
-const arrayDiff = (array1, array2, strict = false) => {
-  return array1.filter(item => !inArray(item, array2, 0, strict));
+export var array_unique = arrayUnique;
+export var arrayDiff = function arrayDiff(array1, array2) {
+  var strict = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return array1.filter(function (item) {
+    return !inArray(item, array2, 0, strict);
+  });
 };
-exports.arrayDiff = arrayDiff;
-const array_diff = exports.array_diff = arrayUnique;
-const range = function (size, startAt = 0, step = 1) {
-  size = (0, _math.round)(size);
-  step = (0, _math.round)(step);
-  const rng = [];
-  if ((0, _is.isUndefined)(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
+export var array_diff = arrayUnique;
+export var range = function range(size) {
+  var startAt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  size = round(size);
+  step = round(step);
+  var rng = [];
+  if (isUndefined(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
     return rng;
   }
-  const end = size * step;
-  if ((0, _is.isString)(startAt)) {
+  var end = size * step;
+  if (isString(startAt)) {
     startAt = startAt.charCodeAt(0);
-    for (let i = 0; step > 0 ? i < end : i > end; i += step) {
+    for (var i = 0; step > 0 ? i < end : i > end; i += step) {
       rng.push(String.fromCharCode(startAt + i));
     }
-  } else if ((0, _is.isInteger)(startAt)) {
-    for (let i = 0; step > 0 ? i < end : i > end; i += step) {
-      rng.push(startAt + i);
+  } else if (isInteger(startAt)) {
+    for (var _i = 0; step > 0 ? _i < end : _i > end; _i += step) {
+      rng.push(startAt + _i);
     }
   }
   return rng;
-};
-exports.range = range;
+};