@webalternatif/js-core 1.1.1 → 1.1.3

package/dist/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webalternatif/js-core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "types": "types/index.d.ts",
   "main": "dist/cjs/index.js",
@@ -16,7 +16,7 @@
     "test": "jest --coverage",
     "test:watch": "jest --watch",
     "build:esm": "babel src --out-dir dist/esm --extensions .js",
-    "build:cjs": "babel src --out-dir dist/cjs --extensions .js --plugins @babel/plugin-transform-modules-commonjs",
+    "build:cjs": "babel src --out-dir dist/cjs --extensions .js",
     "types": "tsc",
     "build": "yarn build:esm && yarn build:cjs && yarn types",
     "readme": "documentation readme src/index.js --section=API --github"
@@ -24,6 +24,7 @@
   "devDependencies": {
     "@babel/cli": "^7.28.3",
     "@babel/core": "^7.26.0",
+    "@babel/plugin-transform-export-namespace-from": "^7.27.1",
     "@babel/preset-env": "^7.26.0",
     "@testing-library/dom": "^10.4.1",
     "@types/jest": "^29.5.14",

package/types/dom.d.ts

@@ -15,29 +15,29 @@ declare namespace _default {
      */
     function child(el: Element, selector?: string): Element | null;
     /**
-     * @param {Element|Document|string} refEl
-     * @param {string} [selector='*']
-     * @returns {NodeList}
+     * @param {Element|Document} refEl
+     * @param {string|Element|NodeList|Array<Element>} [selector]
+     * @returns {Element|null}
      */
-    function find(refEl: Element | Document | string, selector?: string): NodeList;
+    function findOne(refEl: Element | Document, selector?: string | Element | NodeList | Array<Element>): Element | null;
     /**
-     * @param {Element|Document|string} refEl
-     * @param {string} [selector='*']
-     * @returns {Element|null}
+     * @param {Element|Document} refEl
+     * @param {string|Element|NodeList|Array<Element>} selector
+     * @returns {Array<Element>}
      */
-    function findOne(refEl: Element | Document | string, selector?: string): Element | null;
+    function find(refEl: Element | Document, selector: string | Element | NodeList | Array<Element>): Array<Element>;
     /**
-     * @param {Element} el
+     * @param {Element|NodeList|Array<Element>} el
      * @param {string} className
-     * @returns {Element}
+     * @returns {Element|NodeList|Array<Element>}
      */
-    function addClass(el: Element, className: string): Element;
+    function addClass(el: Element | NodeList | Array<Element>, className: string): Element | NodeList | Array<Element>;
     /**
-     * @param {Element} el
-     * @param {string} classNames
-     * @returns {Element}
+     * @param {Element|NodeList|Array<Element>} el
+     * @param {string} className
+     * @returns {Element|NodeList|Array<Element>}
      */
-    function removeClass(el: Element, classNames: string): Element;
+    function removeClass(el: Element | NodeList | Array<Element>, className: string): Element | NodeList | Array<Element>;
     /**
      * @param {Element} el
      * @param {string} classNames
@@ -52,28 +52,28 @@ declare namespace _default {
      */
     function hasClass(el: Element, classNames: string): boolean;
     /**
-     * @param {Element} el
-     * @param {Element} child
-     * @returns {Element}
+     * @param {Node} node
+     * @param {...Node} children
+     * @returns {Node}
      */
-    function append(el: Element, child: Element): Element;
+    function append(node: Node, ...children: Node[]): Node;
     /**
-     * @param {Element} el
-     * @param {Element} child
-     * @returns {Element}
+     * @param {Node} node
+     * @param {...Node} children
+     * @returns {Node}
      */
-    function prepend(el: Element, child: Element): Element;
+    function prepend(node: Node, ...children: Node[]): Node;
     /**
-     * @param {Element} el
+     * @param {Element|NodeList|Array<Element>|string} els
      * @returns {void}
      */
-    function remove(el: Element): void;
+    function remove(...els: Element | NodeList | Array<Element> | string): void;
     /**
      * @param {Element} el
-     * @param {string} [selector]
+     * @param {string|Element} selector
      * @returns {Element|null}
      */
-    function closest(el: Element, selector?: string): Element | null;
+    function closest(el: Element, selector: string | Element): Element | null;
     /**
      * @param {Element} el
      * @param {string} [selector]
@@ -98,6 +98,18 @@ declare namespace _default {
      * @returns {Element[]}
      */
     function prevAll(el: Element, selector?: string): Element[];
+    /**
+     * @param {Element} el
+     * @param {Element|string} selector
+     * @returns {Element[]}
+     */
+    function nextUntil(el: Element, selector: Element | string): Element[];
+    /**
+     * @param {Element} el
+     * @param {Element|string} selector
+     * @returns {Element[]}
+     */
+    function prevUntil(el: Element, selector: Element | string): Element[];
     /**
      * @param {Element} el
      * @param {Element} wrappingElement
@@ -149,11 +161,11 @@ declare namespace _default {
      * @param {Element} el
      * @param {Object<string, string>|string} name
      * @param {string} [value]
-     * @returns {Element}
+     * @returns {Element|DOMStringMap}
      */
     function data(el: Element, name: {
         [x: string]: string;
-    } | string, value?: string): Element;
+    } | string, value?: string): Element | DOMStringMap;
     /**
      * @param {Element} el
      * @param {string} name
@@ -178,11 +190,11 @@ declare namespace _default {
     function off(el: Element | Document | Window, event: string, handler: Function, options: Object): Element;
     /**
      * @param {HTMLElement} el
-     * @param {Object<string, string>|string} styles
+     * @param {Object<string, string>|string} style
      * @param {string} [value]
      * @returns {Element}
      */
-    function css(el: HTMLElement, styles: {
+    function css(el: HTMLElement, style: {
         [x: string]: string;
     } | string, value?: string): Element;
     /**
@@ -205,15 +217,15 @@ declare namespace _default {
      */
     function first(nodeList: NodeList): Element | null;
     /**
-     * @param {NodeList} nodeList
+     * @param {NodeList|Array<Element>} nodeList
      * @returns {Element|null}
      */
-    function last(nodeList: NodeList): Element | null;
+    function last(nodeList: NodeList | Array<Element>): Element | null;
     /**
      * @param {string} html
-     * @returns {Element}
+     * @returns {Element|null}
      */
-    function create(html: string): Element;
+    function create(html: string): Element | null;
     /**
      * @param {NodeList} nodeList
      * @param {number} [index=0]
@@ -237,5 +249,11 @@ declare namespace _default {
      * @returns {Element}
      */
     function empty(el: Element): Element;
+    /**
+     * @param {Element|NodeList} el
+     * @param {string|Element} selector
+     * @return {Element[]}
+     */
+    function not(el: Element | NodeList, selector: string | Element): Element[];
 }
 export default _default;