@angular-wave/angular.ts 0.0.39 → 0.0.41

package/src/shared/jqlite/jqlite.js

@@ -12,12 +12,10 @@ import {
   lowercase,
   nodeName_,
   shallowCopy,
-  trim,
 } from "../../shared/utils";
 import { CACHE, EXPANDO } from "../../core/cache/cache";
 
 /**
- * @ngdoc function
  * @name angular.element
  * @module ng
  * @kind function
@@ -26,24 +24,23 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element. Regardless of the presence of jQuery, `angular.element`
  * delegates to AngularJS's built-in subset of jQuery, called "jQuery lite" or **jqLite**.
  *
- * jqLite is a tiny, API-compatible subset of jQuery that allows
- * AngularJS to manipulate the DOM in a cross-browser compatible way. jqLite implements only the most
+ * JQLite is a tiny, API-compatible subset of jQuery that allows
+ * AngularJS to manipulate the DOM in a cross-browser compatible way. JQLite implements only the most
  * commonly needed functionality with the goal of having a very small footprint.
  *
- *
  * <div class="alert alert-info">**Note:** All element references in AngularJS are always wrapped with
- * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
+ * JQLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.</div>
  *
  * <div class="alert alert-warning">**Note:** Keep in mind that this function will not find elements
  * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
  * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.</div>
  *
- * ## AngularJS's jqLite
- * jqLite provides only the following jQuery methods:
+ * ## AngularJS's JQLite
+ * JQLite provides only the following jQuery methods:
  *
  * - [`after()`](http://api.jquery.com/after/)
  * - [`append()`](http://api.jquery.com/append/) - Contrary to jQuery, this doesn't clone elements
- *   so will not work correctly when invoked on a jqLite object containing more than one DOM node
+ *   so will not work correctly when invoked on a JQLite object containing more than one DOM node
  * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
  * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
  * - [`data()`](http://api.jquery.com/data/)
@@ -52,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/)
@@ -63,10 +59,10 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  * - [`val()`](http://api.jquery.com/val/)
  *
  * ## jQuery/jqLite Extras
- * AngularJS also provides the following additional methods and events to both jQuery and jqLite:
+ * AngularJS also provides the following additional methods and events to both jQuery and JQLite:
  *
  * ### Events
- * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
+ * - `$destroy` - AngularJS intercepts all JQLite/jQuery's DOM destruction apis and fires this event
  *    on all DOM nodes being removed.  This can be used to clean up any 3rd party bindings to the DOM
  *    element before it is removed.
  *
@@ -93,6 +89,7 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  * @returns {Object} jQuery object.
  */
 
+/** @type {number} */
 let jqId = 1;
 
 function jqNextId() {
@@ -102,7 +99,7 @@ function jqNextId() {
 const DASH_LOWERCASE_REGEXP = /-([a-z])/g;
 const UNDERSCORE_LOWERCASE_REGEXP = /_([a-z])/g;
 const MOUSE_EVENT_MAP = { mouseleave: "mouseout", mouseenter: "mouseover" };
-const jqLiteMinErr = minErr("jqLite");
+const JQLiteMinErr = minErr("jqLite");
 
 /**
  * @param {string} _all
@@ -153,177 +150,66 @@ 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 [];
-}
-
-// IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
-const jqLiteContains =
-  window.Node.prototype.contains ||
-  function (arg) {
-    return !!(this.compareDocumentPosition(arg) & 16);
-  };
-
-/// //////////////////////////////////////////
 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) !== "<") {
-      throw jqLiteMinErr(
+    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",
+        "Looking up elements via selectors is not supported by JQLite! See: http://docs.angularjs.org/api/angular.element",
       );
     }
     return new 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);
   }
 }
-export var jqLite = JQLite;
-
-jqLite.CACHE = CACHE;
-
-/**
- * @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) {
+function JQLiteOff(element, type, fn, unsupported) {
   if (isDefined(unsupported))
-    throw jqLiteMinErr(
+    throw JQLiteMinErr(
       "offargs",
       "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;
 
@@ -366,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);
 
@@ -382,12 +268,15 @@ function jqLiteRemoveData(element, name) {
 }
 
 /**
+ * Stores data associated with an element inside the expando property of the DOM element.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Expando MDN Glossary: Expando}
  *
  * @param {Element} element
- * @param {boolean} createIfNecessary
- * @returns {import("./core/cache").ExpandoStore}
+ * @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);
 
@@ -404,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) {
@@ -429,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
   }
 }
 
@@ -462,11 +480,11 @@ function addNodes(root, elements) {
   }
 }
 
-function jqLiteController(element, name) {
-  return jqLiteInheritedData(element, `$${name || "ngController"}Controller`);
+function JQLiteController(element, name) {
+  return JQLiteInheritedData(element, `$${name || "ngController"}Controller`);
 }
 
-function jqLiteInheritedData(element, name, value) {
+function JQLiteInheritedData(element, name, value) {
   // if element is the document object work with the html element instead
   // this makes $(document).scope() possible
   if (element.nodeType === Node.DOCUMENT_NODE) {
@@ -476,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
@@ -488,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);
   }
 }
 
@@ -526,7 +540,6 @@ function jqLiteReady(fn) {
 // Functions which are declared directly.
 /// ///////////////////////////////////////
 JQLite.prototype = {
-  ready: jqLiteReady,
   toString() {
     const value = [];
     forEach(this, (e) => {
@@ -536,32 +549,76 @@ JQLite.prototype = {
   },
 
   eq(index) {
-    return index >= 0 ? jqLite(this[index]) : jqLite(this[this.length + index]);
+    return index >= 0 ? JQLite(this[index]) : JQLite(this[this.length + index]);
   },
 
   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').angular.InjectorService}
+ */
+JQLite.prototype.injector = function () {
+  return JQLiteInheritedData(this[0], "$injector");
+};
 
 export function getBooleanAttrName(element, name) {
   // check dom last since we will most likely fail on name
@@ -571,58 +628,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");
+      JQLite(nodes[i]).triggerHandler("$destroy");
     }
-    jqLiteRemoveData(nodes[i]);
-    jqLiteOff(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,
-    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");
-    },
-
+    data: getOrSetCacheData,
+    inheritedData: JQLiteInheritedData,
     attr(element, name, value) {
       let ret;
       const { nodeType } = element;
@@ -672,7 +702,6 @@ forEach(
         element.textContent = value;
       }
     })(),
-
     val(element, value) {
       if (isUndefined(value)) {
         if (element.multiple && nodeName_(element) === "select") {
@@ -688,7 +717,6 @@ forEach(
       }
       element.value = value;
     },
-
     html(element, value) {
       if (isUndefined(value)) {
         return element.innerHTML;
@@ -696,8 +724,6 @@ forEach(
       dealoc(element, true);
       element.innerHTML = value;
     },
-
-    empty: jqLiteEmpty,
   },
   (fn, name) => {
     /**
@@ -708,15 +734,14 @@ forEach(
       let key;
       const nodeCount = this.length;
 
-      // jqLiteEmpty takes no arguments but is a setter.
+      // JQLiteEmpty takes no arguments but is a setter.
       if (
-        fn !== jqLiteEmpty &&
-        isUndefined(fn.length === 2 && fn !== jqLiteController ? arg1 : arg2)
+        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) {
@@ -748,78 +773,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);
-}
-
-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 && !jqLiteContains.call(target, related))
-  ) {
-    handler.call(target, event);
-  }
-}
-
 /// ///////////////////////////////////////
 // Functions iterating traversal.
 // These functions chain results into a single
@@ -827,25 +780,17 @@ 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",
-        );
-
+    removeData: removeElementData,
+    on: (element, type, fn) => {
       // 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;
+      const expandoStore = getExpando(element, true);
 
-      if (!handle) {
-        handle = expandoStore.handle = createEventHandler(element, events);
+      if (!expandoStore.handle) {
+        expandoStore.handle = createEventHandler(element, expandoStore.events);
       }
 
       // http://jsperf.com/string-indexof-vs-split
@@ -857,13 +802,13 @@ forEach(
         specialHandlerWrapper,
         noEventListener,
       ) {
-        let eventFns = events[type];
+        let eventFns = expandoStore.events[type];
 
         if (!eventFns) {
-          eventFns = events[type] = [];
+          eventFns = expandoStore.events[type] = [];
           eventFns.specialHandlerWrapper = specialHandlerWrapper;
           if (type !== "$destroy" && !noEventListener) {
-            element.addEventListener(type, handle);
+            element.addEventListener(type, expandoStore.handle);
           }
         }
 
@@ -880,9 +825,7 @@ forEach(
         }
       }
     },
-
-    off: jqLiteOff,
-
+    off: JQLiteOff,
     replaceWith(element, replaceNode) {
       let index;
       const parent = element.parentNode;
@@ -896,13 +839,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 (
@@ -928,10 +869,10 @@ forEach(
       }
     },
 
-    remove: jqLiteRemove,
+    remove: removeElement,
 
     detach(element) {
-      jqLiteRemove(element, true);
+      removeElement(element, true);
     },
 
     after(element, newElement) {
@@ -956,7 +897,7 @@ forEach(
         : null;
     },
 
-    // TODO: remove after migrating tests away from jqLite
+    // TODO: remove after migrating tests away from JQLite
     find(element, selector) {
       if (element.getElementsByTagName) {
         return element.getElementsByTagName(selector);
@@ -969,7 +910,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];
 
@@ -1024,7 +965,7 @@ forEach(
           value = fn(this[i], arg1, arg2, arg3);
           if (isDefined(value)) {
             // any function which returns a value needs to be wrapped
-            value = jqLite(value);
+            value = JQLite(value);
           }
         } else {
           addNodes(value, fn(this[i], arg1, arg2, arg3));
@@ -1035,14 +976,88 @@ 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.
  */
 export function startingTag(elementStr) {
-  const clone = jqLite(elementStr)[0].cloneNode(true);
-  const element = jqLite(clone).empty();
-  var elemHtml = jqLite("<div></div>").append(element).html();
+  const clone = JQLite(elementStr)[0].cloneNode(true);
+  const element = JQLite(clone).empty();
+  var elemHtml = JQLite("<div></div>").append(element).html();
   try {
     return element[0].nodeType === Node.TEXT_NODE
       ? lowercase(elemHtml)
@@ -1059,7 +1074,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?
@@ -1071,11 +1086,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);
 }