@angular-wave/angular.ts 0.0.40 → 0.0.42

package/src/shared/jqlite/jqlite.js

@@ -12,7 +12,6 @@ import {
   lowercase,
   nodeName_,
   shallowCopy,
-  trim,
 } from "../../shared/utils";
 import { CACHE, EXPANDO } from "../../core/cache/cache";
 
@@ -50,7 +49,6 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  * - [`html()`](http://api.jquery.com/html/)
  * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
  * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
- * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
  * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
  * - [`prepend()`](http://api.jquery.com/prepend/)
  * - [`remove()`](http://api.jquery.com/remove/)
@@ -152,107 +150,40 @@ wrapMap.tbody =
     wrapMap.thead;
 wrapMap.th = wrapMap.td;
 
-/**
- * Checks if the string contains HTML tags or entities.
- * @param {string} html
- * @returns {boolean}
- */
-export function isTextNode(html) {
-  return !/<|&#?\w+;/.test(html);
-}
+export const BOOLEAN_ATTR = {};
+"multiple,selected,checked,disabled,readOnly,required,open"
+  .split(",")
+  .forEach((value) => {
+    BOOLEAN_ATTR[lowercase(value)] = value;
+  });
+const BOOLEAN_ELEMENTS = {};
+"input,select,option,textarea,button,form,details"
+  .split(",")
+  .forEach((value) => {
+    BOOLEAN_ELEMENTS[value] = true;
+  });
 
 /**
+ * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+ * and execution of chain functions.
  *
- * @param {Element} node
- * @returns {boolean}
+ * @param {string|Element|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @returns {JQLite}
  */
-function elementAcceptsData(node) {
-  // The window object can accept data but has no nodeType
-  // Otherwise we are only interested in elements (1) and documents (9)
-  switch (node.nodeType) {
-    case Node.ELEMENT_NODE:
-    case Node.DOCUMENT_NODE:
-    case undefined:
-      return true;
-    default:
-      return false;
-  }
-}
-
-export function JQLiteBuildFragment(html, context) {
-  let tmp;
-  let tag;
-  let wrap;
-  let finalHtml;
-  const fragment = context.createDocumentFragment();
-  let nodes = [];
-  let i;
-
-  if (isTextNode(html)) {
-    // Convert non-html into a text node
-    nodes.push(context.createTextNode(html));
-  } else {
-    // Convert html into DOM nodes
-    tmp = fragment.appendChild(context.createElement("div"));
-    tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase();
-    finalHtml = html;
-
-    wrap = wrapMap[tag] || [];
-
-    // Create wrappers & descend into them
-    i = wrap.length;
-    while (--i > -1) {
-      tmp.appendChild(window.document.createElement(wrap[i]));
-      tmp = tmp.firstChild;
-    }
-
-    tmp.innerHTML = finalHtml;
-
-    nodes = concat(nodes, tmp.childNodes);
-
-    tmp = fragment.firstChild;
-    tmp.textContent = "";
-  }
-
-  // Remove wrapper from fragment
-  fragment.textContent = "";
-  fragment.innerHTML = ""; // Clear inner HTML
-  forEach(nodes, (node) => {
-    fragment.appendChild(node);
-  });
-
-  return fragment;
-}
-
-function JQLiteParseHTML(html, context) {
-  context = context || window.document;
-  let parsed;
-
-  if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
-    return [context.createElement(parsed[1])];
-  }
-
-  if ((parsed = JQLiteBuildFragment(html, context))) {
-    return parsed.childNodes;
-  }
-
-  return [];
-}
-
-/// //////////////////////////////////////////
 export function JQLite(element) {
   if (element instanceof JQLite) {
     return element;
   }
 
-  let argIsString;
+  let argIsString = false;
 
   if (isString(element)) {
-    element = trim(element);
+    element = /** @type {string} */ (element).trim();
     argIsString = true;
   }
+
   if (!(this instanceof JQLite)) {
-    if (argIsString && element.charAt(0) !== "<") {
+    if (argIsString && /** @type {string} */ (element).charAt(0) !== "<") {
       throw JQLiteMinErr(
         "nosel",
         "Looking up elements via selectors is not supported by JQLite! See: http://docs.angularjs.org/api/angular.element",
@@ -262,49 +193,15 @@ export function JQLite(element) {
   }
 
   if (argIsString) {
-    const parsed = JQLiteParseHTML(element);
+    const parsed = parseHtml(/** @type {string} */ (element));
     addNodes(this, parsed);
   } else if (isFunction(element)) {
-    JQLiteReady(element);
+    onReady(/** @type {Function} */ (element));
   } else {
     addNodes(this, element);
   }
 }
 
-/**
- * @param {Element} element
- * @param {boolean} [onlyDescendants]
- * @returns {void}
- */
-export function dealoc(element, onlyDescendants) {
-  if (!element) return;
-  if (!onlyDescendants && elementAcceptsData(element))
-    JQLiteCleanData([element]);
-
-  if (element.querySelectorAll) {
-    JQLiteCleanData(element.querySelectorAll("*"));
-  }
-}
-
-/**
- * If `ExpandoStore.data` and `ExpandoStore.events` are empty,
- * then delete element's `ExpandoStore` and set its `ExpandoId`
- * to undefined.
- * @param {Element} element
- */
-function removeIfEmptyData(element) {
-  const expandoId = element[EXPANDO];
-  const { events, data } = CACHE.get(expandoId);
-
-  if (
-    (!data || !Object.keys(data).length) &&
-    (!events || !Object.keys(events).length)
-  ) {
-    CACHE.delete(expandoId);
-    element[EXPANDO] = undefined; // don't delete DOM expandos. Chrome don't like it
-  }
-}
-
 function JQLiteOff(element, type, fn, unsupported) {
   if (isDefined(unsupported))
     throw JQLiteMinErr(
@@ -312,7 +209,7 @@ function JQLiteOff(element, type, fn, unsupported) {
       "jqLite#off() does not support the `selector` argument",
     );
 
-  const expandoStore = JQLiteExpandoStore(element);
+  const expandoStore = getExpando(element);
   const events = expandoStore && expandoStore.events;
   const handle = expandoStore && expandoStore.handle;
 
@@ -355,7 +252,7 @@ function JQLiteOff(element, type, fn, unsupported) {
  * @param {Element} element
  * @param {string} [name] - key of field to remove
  */
-function JQLiteRemoveData(element, name) {
+export function removeElementData(element, name) {
   const expandoId = element[EXPANDO];
   const expandoStore = expandoId && CACHE.get(expandoId);
 
@@ -379,7 +276,7 @@ function JQLiteRemoveData(element, name) {
  * @param {boolean} [createIfNecessary=false]
  * @returns {import("../../core/cache/cache").ExpandoStore}
  */
-function JQLiteExpandoStore(element, createIfNecessary = false) {
+function getExpando(element, createIfNecessary = false) {
   let expandoId = element[EXPANDO];
   let expandoStore = expandoId && CACHE.get(expandoId);
 
@@ -396,14 +293,141 @@ function JQLiteExpandoStore(element, createIfNecessary = false) {
   return expandoStore;
 }
 
-function JQLiteData(element, key, value) {
+/**
+ * Checks if the string contains HTML tags or entities.
+ * @param {string} html
+ * @returns {boolean} True if the string is plain text, false if it contains HTML tags or entities.
+ */
+export function isTextNode(html) {
+  return !/<|&#?\w+;/.test(html);
+}
+
+/**
+ * Check if element can accept expando data
+ * @param {Element} node
+ * @returns {boolean}
+ */
+function elementAcceptsData(node) {
+  // The window object can accept data but has no nodeType
+  // Otherwise we are only interested in elements (1) and documents (9)
+  switch (node.nodeType) {
+    case Node.ELEMENT_NODE:
+    case Node.DOCUMENT_NODE:
+    case undefined: // window.object
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * @param {string} html
+ * @returns {DocumentFragment}
+ */
+export function buildFragment(html) {
+  let tmp;
+  let tag;
+  let wrap;
+  let tempFragment = document.createDocumentFragment();
+  let nodes = [];
+  let i;
+
+  if (isTextNode(html)) {
+    // Convert non-html into a text node
+    nodes.push(document.createTextNode(html));
+  } else {
+    // Convert html into DOM nodes
+    tmp = tempFragment.appendChild(document.createElement("div"));
+    tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase();
+
+    wrap = wrapMap[tag] || [];
+
+    // Create wrappers & descend into them
+    i = wrap.length;
+    while (--i > -1) {
+      tmp.appendChild(window.document.createElement(wrap[i]));
+      tmp = tmp.firstChild;
+    }
+    tmp.innerHTML = html;
+
+    nodes = concat(nodes, tmp.childNodes);
+
+    tmp = tempFragment.firstChild;
+    tmp.textContent = "";
+  }
+
+  let fragment = document.createDocumentFragment();
+  fragment.append(...nodes);
+  return fragment;
+}
+
+/**
+ * @param {string} html
+ * @returns {NodeListOf<ChildNode> | HTMLElement[]}
+ */
+function parseHtml(html) {
+  let regEx = SINGLE_TAG_REGEXP.exec(html);
+  if (regEx) {
+    return [document.createElement(regEx[1])];
+  }
+  let fragment = buildFragment(html);
+  if (fragment) {
+    return fragment.childNodes;
+  }
+
+  return [];
+}
+
+/**
+ * @param {Element} element
+ * @param {boolean} [onlyDescendants]
+ * @returns {void}
+ */
+export function dealoc(element, onlyDescendants) {
+  if (!element) return;
+  if (!onlyDescendants && elementAcceptsData(element))
+    cleanElementData([element]);
+
+  if (element.querySelectorAll) {
+    cleanElementData(element.querySelectorAll("*"));
+  }
+}
+
+/**
+ * If `ExpandoStore.data` and `ExpandoStore.events` are empty,
+ * then delete element's `ExpandoStore` and set its `ExpandoId`
+ * to undefined.
+ * @param {Element} element
+ */
+function removeIfEmptyData(element) {
+  const expandoId = element[EXPANDO];
+  const { events, data } = CACHE.get(expandoId);
+
+  if (
+    (!data || !Object.keys(data).length) &&
+    (!events || !Object.keys(events).length)
+  ) {
+    CACHE.delete(expandoId);
+    element[EXPANDO] = undefined; // don't delete DOM expandos. Chrome don't like it
+  }
+}
+
+/**
+ * Gets or sets cache data for a given element.
+ *
+ * @param {Element} element - The DOM element to get or set data on.
+ * @param {string|Object} key - The key (as a string) to get/set or an object for mass-setting.
+ * @param {*} [value] - The value to set. If not provided, the function acts as a getter.
+ * @returns {*} - The retrieved data if acting as a getter. Otherwise, returns undefined.
+ */
+export function getOrSetCacheData(element, key, value) {
   if (elementAcceptsData(element)) {
     let prop;
 
     const isSimpleSetter = isDefined(value);
     const isSimpleGetter = !isSimpleSetter && key && !isObject(key);
     const massGetter = !key;
-    const expandoStore = JQLiteExpandoStore(element, !isSimpleGetter);
+    const expandoStore = getExpando(element, !isSimpleGetter);
     const data = expandoStore && expandoStore.data;
 
     if (isSimpleSetter) {
@@ -421,6 +445,8 @@ function JQLiteData(element, key, value) {
         data[kebabToCamel(prop)] = key[prop];
       }
     }
+  } else {
+    // TODO: check should occur perhaps prior at compilation level that this is a valid element
   }
 }
 
@@ -468,7 +494,8 @@ function JQLiteInheritedData(element, name, value) {
 
   while (element) {
     for (let i = 0, ii = names.length; i < ii; i++) {
-      if (isDefined((value = JQLiteData(element, names[i])))) return value;
+      if (isDefined((value = getOrSetCacheData(element, names[i]))))
+        return value;
     }
 
     // If dealing with a document fragment node with a host element, and no parent, use the host
@@ -480,37 +507,32 @@ function JQLiteInheritedData(element, name, value) {
   }
 }
 
-function JQLiteEmpty(element) {
-  dealoc(element, true);
-  while (element.firstChild) {
-    element.removeChild(element.firstChild);
-  }
-}
-
-export function JQLiteRemove(element, keepData) {
+/**
+ *
+ * @param {Element} element
+ * @param {boolean} keepData
+ */
+export function removeElement(element, keepData = false) {
   if (!keepData) dealoc(element);
   const parent = element.parentNode;
   if (parent) parent.removeChild(element);
 }
 
-function JQLiteReady(fn) {
+/**
+ * Executea a function on `DOMContentLoaded`
+ * @param {Function} fn
+ */
+function onReady(fn) {
   function trigger() {
     window.document.removeEventListener("DOMContentLoaded", trigger);
-    window.removeEventListener("load", trigger);
     fn();
   }
-
   // check if document is already loaded
   if (window.document.readyState === "complete") {
     window.setTimeout(fn);
   } else {
-    // We can not use JQLite since we are not done loading and jQuery could be loaded later.
-
-    // Works for modern browsers and IE9
+    // We can not use JQLite since we are not done loading.
     window.document.addEventListener("DOMContentLoaded", trigger);
-
-    // Fallback to window.onload for others
-    window.addEventListener("load", trigger);
   }
 }
 
@@ -518,7 +540,6 @@ function JQLiteReady(fn) {
 // Functions which are declared directly.
 /// ///////////////////////////////////////
 JQLite.prototype = {
-  ready: JQLiteReady,
   toString() {
     const value = [];
     forEach(this, (e) => {
@@ -532,28 +553,123 @@ JQLite.prototype = {
   },
 
   length: 0,
-  push: [].push,
-  sort: [].sort,
-  splice: [].splice,
 };
 
-/// ///////////////////////////////////////
-// Functions iterating getter/setters.
-// these functions return self on setter and
-// value on get.
-/// ///////////////////////////////////////
-export const BOOLEAN_ATTR = {};
-"multiple,selected,checked,disabled,readOnly,required,open"
-  .split(",")
-  .forEach((value) => {
-    BOOLEAN_ATTR[lowercase(value)] = value;
-  });
-const BOOLEAN_ELEMENTS = {};
-"input,select,option,textarea,button,form,details"
-  .split(",")
-  .forEach((value) => {
-    BOOLEAN_ELEMENTS[value] = true;
-  });
+/**
+ * Remove all child nodes of the set of matched elements from the DOM and clears CACHE data, associated with the node.
+ * @returns {JQLite} The current instance of JQLite.
+ */
+JQLite.prototype.empty = function () {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    dealoc(element, true);
+    // we may run into situation where we empty a transcluded node
+    if (
+      [
+        Node.ELEMENT_NODE,
+        Node.DOCUMENT_NODE,
+        Node.DOCUMENT_FRAGMENT_NODE,
+      ].includes(element.nodeType)
+    ) {
+      element.replaceChildren();
+    }
+  }
+  return this;
+};
+
+/**
+ * Returns the `$scope` of the element.
+ * @returns {import("../../core/scope/scope").Scope}
+ */
+JQLite.prototype.scope = function () {
+  // Can't use JQLiteData here directly so we stay compatible with jQuery!
+  return (
+    getOrSetCacheData(this[0], "$scope") ||
+    JQLiteInheritedData(this[0].parentNode || this[0], [
+      "$isolateScope",
+      "$scope",
+    ])
+  );
+};
+
+/**
+ * Returns the isolate `$scope` of the element.
+ * @returns {import("../../core/scope/scope").Scope}
+ */
+JQLite.prototype.isolateScope = function () {
+  return (
+    getOrSetCacheData(this[0], "$isolateScope") ||
+    getOrSetCacheData(this[0], "$isolateScopeNoTemplate")
+  );
+};
+
+/**
+ * Return instance of controller attached to element
+ * @param {string} [name] - Controller name
+ * @returns {any}
+ */
+JQLite.prototype.controller = function (name) {
+  return JQLiteController(this[0], name);
+};
+
+/**
+ * Return instance of injector attached to element
+ * @returns {import('../../types').InjectorService}
+ */
+JQLite.prototype.injector = function () {
+  return JQLiteInheritedData(this[0], "$injector");
+};
+
+/**
+ * Adds an event listener to each element in the JQLite collection.
+ *
+ * @param {string} type - The event type(s) to listen for. Multiple event types can be specified, separated by a space.
+ * @param {Function} fn - The function to execute when the event is triggered.
+ * @returns {JQLite} The JQLite collection for chaining.
+ */
+JQLite.prototype.on = function (type, fn) {
+  // Do not add event handlers to non-elements because they will not be cleaned up.
+  for (let i = 0, ii = this.length; i < ii; i++) {
+    const element = this[i];
+    if (!elementAcceptsData(element)) {
+      return;
+    }
+
+    const expandoStore = getExpando(element, true);
+
+    if (!expandoStore.handle) {
+      expandoStore.handle = createEventHandler(element, expandoStore.events);
+    }
+    // http://jsperf.com/string-indexof-vs-split
+    const types = type.indexOf(" ") >= 0 ? type.split(" ") : [type];
+    let j = types.length;
+
+    const addHandler = function (type, specialHandlerWrapper, noEventListener) {
+      let eventFns = expandoStore.events[type];
+
+      if (!eventFns) {
+        eventFns = expandoStore.events[type] = [];
+        eventFns.specialHandlerWrapper = specialHandlerWrapper;
+        if (type !== "$destroy" && !noEventListener) {
+          element.addEventListener(type, expandoStore.handle);
+        }
+      }
+
+      eventFns.push(fn);
+    };
+
+    while (j--) {
+      type = types[j];
+      if (MOUSE_EVENT_MAP[type]) {
+        addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
+        addHandler(type, undefined, true);
+      } else {
+        addHandler(type);
+      }
+    }
+  }
+  return this;
+};
 
 export function getBooleanAttrName(element, name) {
   // check dom last since we will most likely fail on name
@@ -563,58 +679,31 @@ export function getBooleanAttrName(element, name) {
   return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
 }
 
-export function JQLiteCleanData(nodes) {
+/**
+ * Takes an array of elements, calls any `$destroy` event handlers, removes any data in cache, and finally removes any
+ * listeners.
+ * @param {NodeListOf<Element>} nodes
+ */
+export function cleanElementData(nodes) {
   for (let i = 0, ii = nodes.length; i < ii; i++) {
     var events = (CACHE.get(nodes[i][EXPANDO]) || {}).events;
     if (events && events.$destroy) {
       JQLite(nodes[i]).triggerHandler("$destroy");
     }
-    JQLiteRemoveData(nodes[i]);
+    removeElementData(nodes[i]);
     JQLiteOff(nodes[i]);
   }
 }
 
+/// ///////////////////////////////////////
+// Functions iterating getter/setters.
+// these functions return self on setter and
+// value on get.
+/// ///////////////////////////////////////
 forEach(
   {
-    data: JQLiteData,
-    removeData: JQLiteRemoveData,
-    cleanData: JQLiteCleanData,
-  },
-  (fn, name) => {
-    JQLite[name] = fn;
-  },
-);
-
-forEach(
-  {
-    data: JQLiteData,
+    data: getOrSetCacheData,
     inheritedData: JQLiteInheritedData,
-
-    scope(element) {
-      // Can't use JQLiteData here directly so we stay compatible with jQuery!
-      return (
-        JQLiteData(element, "$scope") ||
-        JQLiteInheritedData(element.parentNode || element, [
-          "$isolateScope",
-          "$scope",
-        ])
-      );
-    },
-
-    isolateScope(element) {
-      // Can't use JQLiteData here directly so we stay compatible with jQuery!
-      return (
-        JQLiteData(element, "$isolateScope") ||
-        JQLiteData(element, "$isolateScopeNoTemplate")
-      );
-    },
-
-    controller: JQLiteController,
-
-    injector(element) {
-      return JQLiteInheritedData(element, "$injector");
-    },
-
     attr(element, name, value) {
       let ret;
       const { nodeType } = element;
@@ -664,7 +753,6 @@ forEach(
         element.textContent = value;
       }
     })(),
-
     val(element, value) {
       if (isUndefined(value)) {
         if (element.multiple && nodeName_(element) === "select") {
@@ -680,7 +768,6 @@ forEach(
       }
       element.value = value;
     },
-
     html(element, value) {
       if (isUndefined(value)) {
         return element.innerHTML;
@@ -688,8 +775,6 @@ forEach(
       dealoc(element, true);
       element.innerHTML = value;
     },
-
-    empty: JQLiteEmpty,
   },
   (fn, name) => {
     /**
@@ -702,13 +787,12 @@ forEach(
 
       // JQLiteEmpty takes no arguments but is a setter.
       if (
-        fn !== JQLiteEmpty &&
         isUndefined(fn.length === 2 && fn !== JQLiteController ? arg1 : arg2)
       ) {
         if (isObject(arg1)) {
           // we are a write, but the object properties are the key/values
           for (i = 0; i < nodeCount; i++) {
-            if (fn === JQLiteData) {
+            if (fn === getOrSetCacheData) {
               fn(this[i], arg1);
             } else {
               for (key in arg1) {
@@ -740,80 +824,6 @@ forEach(
   },
 );
 
-function createEventHandler(element, events) {
-  const eventHandler = function (event, type) {
-    // jQuery specific api
-    event.isDefaultPrevented = function () {
-      return event.defaultPrevented;
-    };
-
-    let eventFns = events[type || event.type];
-    const eventFnsLength = eventFns ? eventFns.length : 0;
-
-    if (!eventFnsLength) return;
-
-    if (isUndefined(event.immediatePropagationStopped)) {
-      const originalStopImmediatePropagation = event.stopImmediatePropagation;
-      event.stopImmediatePropagation = function () {
-        event.immediatePropagationStopped = true;
-
-        if (event.stopPropagation) {
-          event.stopPropagation();
-        }
-
-        if (originalStopImmediatePropagation) {
-          originalStopImmediatePropagation.call(event);
-        }
-      };
-    }
-
-    event.isImmediatePropagationStopped = function () {
-      return event.immediatePropagationStopped === true;
-    };
-
-    // Some events have special handlers that wrap the real handler
-    const handlerWrapper =
-      eventFns.specialHandlerWrapper || defaultHandlerWrapper;
-
-    // Copy event handlers in case event handlers array is modified during execution.
-    if (eventFnsLength > 1) {
-      eventFns = shallowCopy(eventFns);
-    }
-
-    for (let i = 0; i < eventFnsLength; i++) {
-      if (!event.isImmediatePropagationStopped()) {
-        handlerWrapper(element, event, eventFns[i]);
-      }
-    }
-  };
-
-  // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
-  //       events on `element`
-  eventHandler.elem = element;
-  return eventHandler;
-}
-
-function defaultHandlerWrapper(element, event, handler) {
-  handler.call(element, event);
-}
-
-/**
- * @param {Node} target
- * @param {*} event
- * @param {*} handler
- */
-function specialMouseHandlerWrapper(target, event, handler) {
-  // Refer to jQuery's implementation of mouseenter & mouseleave
-  // Read about mouseenter and mouseleave:
-  // http://www.quirksmode.org/js/events_mouse.html#link8
-  const related = event.relatedTarget;
-  // For mousenter/leave call the handler if related is outside the target.
-  // NB: No relatedTarget if the mouse left/entered the browser window
-  if (!related || (related !== target && !target.contains(related))) {
-    handler.call(target, event);
-  }
-}
-
 /// ///////////////////////////////////////
 // Functions iterating traversal.
 // These functions chain results into a single
@@ -821,62 +831,9 @@ function specialMouseHandlerWrapper(target, event, handler) {
 /// ///////////////////////////////////////
 forEach(
   {
-    removeData: JQLiteRemoveData,
-    on: (element, type, fn, unsupported) => {
-      if (isDefined(unsupported))
-        throw JQLiteMinErr(
-          "onargs",
-          "jqLite#on() does not support the `selector` or `eventData` parameters",
-        );
-
-      // Do not add event handlers to non-elements because they will not be cleaned up.
-      if (!elementAcceptsData(element)) {
-        return;
-      }
-
-      const expandoStore = JQLiteExpandoStore(element, true);
-      const { events } = expandoStore;
-      let { handle } = expandoStore;
-
-      if (!handle) {
-        handle = expandoStore.handle = createEventHandler(element, events);
-      }
-
-      // http://jsperf.com/string-indexof-vs-split
-      const types = type.indexOf(" ") >= 0 ? type.split(" ") : [type];
-      let i = types.length;
-
-      const addHandler = function (
-        type,
-        specialHandlerWrapper,
-        noEventListener,
-      ) {
-        let eventFns = events[type];
-
-        if (!eventFns) {
-          eventFns = events[type] = [];
-          eventFns.specialHandlerWrapper = specialHandlerWrapper;
-          if (type !== "$destroy" && !noEventListener) {
-            element.addEventListener(type, handle);
-          }
-        }
-
-        eventFns.push(fn);
-      };
-
-      while (i--) {
-        type = types[i];
-        if (MOUSE_EVENT_MAP[type]) {
-          addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
-          addHandler(type, undefined, true);
-        } else {
-          addHandler(type);
-        }
-      }
-    },
+    removeData: removeElementData,
 
     off: JQLiteOff,
-
     replaceWith(element, replaceNode) {
       let index;
       const parent = element.parentNode;
@@ -890,13 +847,11 @@ forEach(
         index = node;
       });
     },
-
     children(element) {
       return Array.from(element.childNodes).filter(
         (child) => child.nodeType === Node.ELEMENT_NODE,
       );
     },
-
     append(element, node) {
       const { nodeType } = element;
       if (
@@ -922,10 +877,10 @@ forEach(
       }
     },
 
-    remove: JQLiteRemove,
+    remove: removeElement,
 
     detach(element) {
-      JQLiteRemove(element, true);
+      removeElement(element, true);
     },
 
     after(element, newElement) {
@@ -963,7 +918,7 @@ forEach(
       let eventFnsCopy;
       let handlerArgs;
       const eventName = event.type || event;
-      const expandoStore = JQLiteExpandoStore(element);
+      const expandoStore = getExpando(element);
       const events = expandoStore && expandoStore.events;
       const eventFns = events && events[eventName];
 
@@ -1029,6 +984,80 @@ forEach(
   },
 );
 
+function createEventHandler(element, events) {
+  const eventHandler = function (event, type) {
+    // jQuery specific api
+    event.isDefaultPrevented = function () {
+      return event.defaultPrevented;
+    };
+
+    let eventFns = events[type || event.type];
+    const eventFnsLength = eventFns ? eventFns.length : 0;
+
+    if (!eventFnsLength) return;
+
+    if (isUndefined(event.immediatePropagationStopped)) {
+      const originalStopImmediatePropagation = event.stopImmediatePropagation;
+      event.stopImmediatePropagation = function () {
+        event.immediatePropagationStopped = true;
+
+        if (event.stopPropagation) {
+          event.stopPropagation();
+        }
+
+        if (originalStopImmediatePropagation) {
+          originalStopImmediatePropagation.call(event);
+        }
+      };
+    }
+
+    event.isImmediatePropagationStopped = function () {
+      return event.immediatePropagationStopped === true;
+    };
+
+    // Some events have special handlers that wrap the real handler
+    const handlerWrapper =
+      eventFns.specialHandlerWrapper || defaultHandlerWrapper;
+
+    // Copy event handlers in case event handlers array is modified during execution.
+    if (eventFnsLength > 1) {
+      eventFns = shallowCopy(eventFns);
+    }
+
+    for (let i = 0; i < eventFnsLength; i++) {
+      if (!event.isImmediatePropagationStopped()) {
+        handlerWrapper(element, event, eventFns[i]);
+      }
+    }
+  };
+
+  // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
+  //       events on `element`
+  eventHandler.elem = element;
+  return eventHandler;
+}
+
+function defaultHandlerWrapper(element, event, handler) {
+  handler.call(element, event);
+}
+
+/**
+ * @param {Node} target
+ * @param {*} event
+ * @param {*} handler
+ */
+function specialMouseHandlerWrapper(target, event, handler) {
+  // Refer to jQuery's implementation of mouseenter & mouseleave
+  // Read about mouseenter and mouseleave:
+  // http://www.quirksmode.org/js/events_mouse.html#link8
+  const related = event.relatedTarget;
+  // For mousenter/leave call the handler if related is outside the target.
+  // NB: No relatedTarget if the mouse left/entered the browser window
+  if (!related || (related !== target && !target.contains(related))) {
+    handler.call(target, event);
+  }
+}
+
 /**
  * @param {string} elementStr
  * @returns {string} Returns the string representation of the element.
@@ -1053,7 +1082,7 @@ export function startingTag(elementStr) {
 /**
  * Return the DOM siblings between the first and last node in the given array.
  * @param {Array} nodes An array-like object
- * @returns {Array} the inputted object or a JQLite collection containing the nodes
+ * @returns {JQLite} the inputted object or a JQLite collection containing the nodes
  */
 export function getBlockNodes(nodes) {
   // TODO(perf): update `nodes` instead of creating a new object?
@@ -1065,11 +1094,11 @@ export function getBlockNodes(nodes) {
     if (blockNodes || nodes[i] !== node) {
       if (!blockNodes) {
         // use element to avoid circular dependency
-        blockNodes = JQLite(Array.prototype.slice.call(nodes, 0, i));
+        blockNodes = Array.prototype.slice.call(nodes, 0, i);
       }
       blockNodes.push(node);
     }
   }
 
-  return blockNodes || nodes;
+  return JQLite(blockNodes || nodes);
 }