From 9431e584406f51bf222a5b05c1b3da429a773339 Mon Sep 17 00:00:00 2001
From: Artur Arseniev <artur.catch@hotmail.it>
Date: Wed, 3 Nov 2021 12:52:11 +0100
Subject: [PATCH] Move cash

---
 package.json               |    1 -
 src/editor/model/Editor.js |    3 +-
 src/index.js               |    6 +-
 src/utils/cash-dom.js      | 1436 ++++++++++++++++++++++++++++++++++++
 4 files changed, 1439 insertions(+), 7 deletions(-)
 create mode 100644 src/utils/cash-dom.js

diff --git a/package.json b/package.json
index 1a017ec1c..bd6439edb 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,6 @@
   "dependencies": {
     "backbone": "1.3.3",
     "backbone-undo": "^0.2.5",
-    "cash-dom": "^2.3.9",
     "codemirror": "^5.63.0",
     "codemirror-formatting": "^1.0.0",
     "promise-polyfill": "^8.1.3",
diff --git a/src/editor/model/Editor.js b/src/editor/model/Editor.js
index 8144d9fc7..8c5c5188b 100644
--- a/src/editor/model/Editor.js
+++ b/src/editor/model/Editor.js
@@ -8,12 +8,11 @@ import {
   bindAll
 } from 'underscore';
 import Backbone from 'backbone';
+import $ from 'utils/cash-dom';
 import Extender from 'utils/extender';
 import { getModel, hasWin } from 'utils/mixins';
 import Selected from './Selected';
 
-const cash = hasWin() ? require('cash-dom') : null;
-const $ = (cash && cash.default) || cash;
 Backbone.$ = $;
 
 const deps = [
diff --git a/src/index.js b/src/index.js
index 6793e71ad..7499251f0 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,15 +1,13 @@
-import Editor from './editor';
 import { isElement, isFunction } from 'underscore';
+import $ from 'utils/cash-dom';
+import Editor from './editor';
 import polyfills from 'utils/polyfills';
 import PluginManager from './plugin_manager';
-import { hasWin } from 'utils/mixins';
 
 polyfills();
 
 const plugins = new PluginManager();
 const editors = [];
-const cash = hasWin() ? require('cash-dom') : null;
-const $ = (cash && cash.default) || cash;
 const defaultConfig = {
   // If true renders editor on init
   autorender: 1,
diff --git a/src/utils/cash-dom.js b/src/utils/cash-dom.js
new file mode 100644
index 000000000..3efb36fcf
--- /dev/null
+++ b/src/utils/cash-dom.js
@@ -0,0 +1,1436 @@
+/* Adapted for headless */
+/* MIT https://github.com/kenwheeler/cash */
+'use strict';
+
+var doc = typeof document !== 'undefined' ? document : null,
+  win = typeof window !== 'undefined' ? window : null,
+  _Array$prototype = Array.prototype,
+  filter = _Array$prototype.filter,
+  indexOf = _Array$prototype.indexOf,
+  map = _Array$prototype.map,
+  push = _Array$prototype.push,
+  reverse = _Array$prototype.reverse,
+  slice = _Array$prototype.slice,
+  splice = _Array$prototype.splice;
+var idRe = /^#[\w-]*$/,
+  classRe = /^\.[\w-]*$/,
+  htmlRe = /<.+>/,
+  tagRe = /^\w+$/; // @require ./variables.js
+
+function find(selector, context) {
+  if (context === void 0) {
+    context = doc;
+  }
+
+  return classRe.test(selector)
+    ? context.getElementsByClassName(selector.slice(1))
+    : tagRe.test(selector)
+    ? context.getElementsByTagName(selector)
+    : context.querySelectorAll(selector);
+} // @require ./find.js
+// @require ./variables.js
+
+function Cash(selector, context) {
+  if (context === void 0) {
+    context = doc;
+  }
+
+  if (!selector) return;
+  if (selector.__cash) return selector;
+  var eles = selector;
+
+  if (isString(selector)) {
+    if (context.__cash) context = context[0];
+    eles = idRe.test(selector)
+      ? context.getElementById(selector.slice(1))
+      : htmlRe.test(selector)
+      ? parseHTML(selector)
+      : find(selector, context);
+    if (!eles) return;
+  } else if (isFunction(selector)) {
+    return this.ready(selector); //FIXME: `fn.ready` is not included in `core`, but it's actually a core functionality
+  }
+
+  if (eles.nodeType || eles === win) eles = [eles];
+  this.length = eles.length;
+
+  for (var i = 0, l = this.length; i < l; i++) {
+    this[i] = eles[i];
+  }
+}
+
+function cash(selector, context) {
+  return new Cash(selector, context);
+}
+/* PROTOTYPE */
+
+var fn = (cash.fn = cash.prototype = Cash.prototype = {
+  constructor: cash,
+  __cash: true,
+  length: 0,
+  splice: splice // Ensures a cash collection gets printed as array-like in Chrome
+}); // @require core/cash.js
+// @require core/variables.js
+
+fn.get = function(index) {
+  if (index === undefined) return slice.call(this);
+  return this[index < 0 ? index + this.length : index];
+}; // @require core/cash.js
+// @require ./get.js
+
+fn.eq = function(index) {
+  return cash(this.get(index));
+}; // @require core/cash.js
+// @require ./eq.js
+
+fn.first = function() {
+  return this.eq(0);
+}; // @require core/cash.js
+// @require ./eq.js
+
+fn.last = function() {
+  return this.eq(-1);
+}; // @require core/cash.js
+// @require core/variables.js
+
+fn.map = function(callback) {
+  return cash(
+    map.call(this, function(ele, i) {
+      return callback.call(ele, i, ele);
+    })
+  );
+}; // @require core/cash.js
+// @require core/variables.js
+
+fn.slice = function() {
+  return cash(slice.apply(this, arguments));
+}; // @require ./cash.js
+
+var camelCaseRe = /(?:^\w|[A-Z]|\b\w)/g,
+  camelCaseWhitespaceRe = /[\s-_]+/g;
+
+function camelCase(str) {
+  return str
+    .replace(camelCaseRe, function(letter, index) {
+      return letter[!index ? 'toLowerCase' : 'toUpperCase']();
+    })
+    .replace(camelCaseWhitespaceRe, '');
+}
+
+cash.camelCase = camelCase; // @require ./cash.js
+
+function each(arr, callback) {
+  for (var i = 0, l = arr.length; i < l; i++) {
+    if (callback.call(arr[i], arr[i], i, arr) === false) break;
+  }
+}
+
+cash.each = each; // @require core/cash.js
+// @require core/each.js
+
+fn.each = function(callback) {
+  each(this, function(ele, i) {
+    return callback.call(ele, i, ele);
+  });
+  return this;
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.removeProp = function(prop) {
+  return this.each(function(i, ele) {
+    delete ele[prop];
+  });
+}; // @require ./cash.js
+
+function extend(target) {
+  if (target === void 0) {
+    target = this;
+  }
+
+  var args = arguments,
+    length = args.length;
+
+  for (var i = length < 2 ? 0 : 1; i < length; i++) {
+    for (var key in args[i]) {
+      target[key] = args[i][key];
+    }
+  }
+
+  return target;
+}
+
+cash.extend = fn.extend = extend; // @require ./cash.js
+
+var guid = 1;
+cash.guid = guid; // @require ./cash.js
+
+function matches(ele, selector) {
+  var matches =
+    ele &&
+    (ele.matches ||
+      ele.webkitMatchesSelector ||
+      ele.mozMatchesSelector ||
+      ele.msMatchesSelector ||
+      ele.oMatchesSelector);
+  return !!matches && matches.call(ele, selector);
+}
+
+cash.matches = matches; // @require ./cash.js
+
+function isFunction(x) {
+  return typeof x === 'function';
+}
+
+cash.isFunction = isFunction;
+
+function isString(x) {
+  return typeof x === 'string';
+}
+
+cash.isString = isString;
+
+function isNumeric(x) {
+  return !isNaN(parseFloat(x)) && isFinite(x);
+}
+
+cash.isNumeric = isNumeric;
+var isArray = Array.isArray;
+cash.isArray = isArray; // @require core/cash.js
+// @require core/type_checking.js
+// @require collection/each.js
+
+fn.prop = function(prop, value) {
+  if (!prop) return;
+
+  if (isString(prop)) {
+    if (arguments.length < 2) return this[0] && this[0][prop];
+    return this.each(function(i, ele) {
+      ele[prop] = value;
+    });
+  }
+
+  for (var key in prop) {
+    this.prop(key, prop[key]);
+  }
+
+  return this;
+}; // @require ./matches.js
+// @require ./type_checking.js
+
+function getCompareFunction(selector) {
+  return isString(selector)
+    ? function(i, ele) {
+        return matches(ele, selector);
+      }
+    : selector.__cash
+    ? function(i, ele) {
+        return selector.is(ele);
+      }
+    : function(i, ele, selector) {
+        return ele === selector;
+      };
+} // @require core/cash.js
+// @require core/get_compare_function.js
+// @require core/type_checking.js
+// @require core/variables.js
+// @require collection/get.js
+
+fn.filter = function(selector) {
+  if (!selector) return cash();
+  var comparator = isFunction(selector)
+    ? selector
+    : getCompareFunction(selector);
+  return cash(
+    filter.call(this, function(ele, i) {
+      return comparator.call(ele, i, ele, selector);
+    })
+  );
+}; // @require ./type_checking.js
+
+var splitValuesRe = /\S+/g;
+
+function getSplitValues(str) {
+  return isString(str) ? str.match(splitValuesRe) || [] : [];
+} // @require core/cash.js
+// @require core/get_split_values.js
+// @require collection/each.js
+
+fn.hasClass = function(cls) {
+  var classes = getSplitValues(cls);
+  var check = false;
+
+  if (classes.length) {
+    this.each(function(i, ele) {
+      check = ele.classList.contains(classes[0]);
+      return !check;
+    });
+  }
+
+  return check;
+}; // @require core/cash.js
+// @require core/get_split_values.js
+// @require collection/each.js
+
+fn.removeAttr = function(attr) {
+  var attrs = getSplitValues(attr);
+  if (!attrs.length) return this;
+  return this.each(function(i, ele) {
+    each(attrs, function(a) {
+      ele.removeAttribute(a);
+    });
+  });
+}; // @require core/cash.js
+// @require core/type_checking.js
+// @require collection/each.js
+// @require ./remove_attr.js
+
+fn.attr = function(attr, value) {
+  if (!attr) return;
+
+  if (isString(attr)) {
+    if (arguments.length < 2) {
+      if (!this[0]) return;
+
+      var _value = this[0].getAttribute(attr);
+
+      return _value === null ? undefined : _value;
+    }
+
+    if (value === null) return this.removeAttr(attr);
+    return this.each(function(i, ele) {
+      ele.setAttribute(attr, value);
+    });
+  }
+
+  for (var key in attr) {
+    this.attr(key, attr[key]);
+  }
+
+  return this;
+}; // @require core/cash.js
+// @require core/each.js
+// @require core/get_split_values.js
+// @require collection/each.js
+
+fn.toggleClass = function(cls, force) {
+  var classes = getSplitValues(cls),
+    isForce = force !== undefined;
+  if (!classes.length) return this;
+  return this.each(function(i, ele) {
+    each(classes, function(c) {
+      if (isForce) {
+        force ? ele.classList.add(c) : ele.classList.remove(c);
+      } else {
+        ele.classList.toggle(c);
+      }
+    });
+  });
+}; // @require core/cash.js
+// @require ./toggle_class.js
+
+fn.addClass = function(cls) {
+  return this.toggleClass(cls, true);
+}; // @require core/cash.js
+// @require ./attr.js
+// @require ./toggle_class.js
+
+fn.removeClass = function(cls) {
+  return !arguments.length
+    ? this.attr('class', '')
+    : this.toggleClass(cls, false);
+}; // @optional ./add_class.js
+// @optional ./attr.js
+// @optional ./has_class.js
+// @optional ./prop.js
+// @optional ./remove_attr.js
+// @optional ./remove_class.js
+// @optional ./remove_prop.js
+// @optional ./toggle_class.js
+// @require ./cash.js
+
+function unique(arr) {
+  return arr.filter(function(item, index, self) {
+    return self.indexOf(item) === index;
+  });
+}
+
+cash.unique = unique; // @require core/cash.js
+// @require core/unique.js
+// @require ./get.js
+
+fn.add = function(selector, context) {
+  return cash(unique(this.get().concat(cash(selector, context).get())));
+}; // @require core/variables.js
+
+function computeStyle(ele, prop, isVariable) {
+  if (ele.nodeType !== 1) return;
+  var style = win.getComputedStyle(ele, null);
+  return prop
+    ? isVariable
+      ? style.getPropertyValue(prop)
+      : style[prop]
+    : style;
+} // @require ./compute_style.js
+
+function computeStyleInt(ele, prop) {
+  return parseInt(computeStyle(ele, prop), 10) || 0;
+}
+
+var cssVariableRe = /^--/; // @require ./variables.js
+
+function isCSSVariable(prop) {
+  return cssVariableRe.test(prop);
+} // @require core/camel_case.js
+// @require core/cash.js
+// @require core/each.js
+// @require core/variables.js
+// @require ./is_css_variable.js
+
+var prefixedProps = {},
+  docEl = doc && doc.createElement('div'),
+  style = docEl ? docEl.style : {},
+  vendorsPrefixes = ['webkit', 'moz', 'ms', 'o'];
+
+function getPrefixedProp(prop, isVariable) {
+  if (isVariable === void 0) {
+    isVariable = isCSSVariable(prop);
+  }
+
+  if (isVariable) return prop;
+
+  if (!prefixedProps[prop]) {
+    var propCC = camelCase(prop),
+      propUC = '' + propCC.charAt(0).toUpperCase() + propCC.slice(1),
+      props = (
+        propCC +
+        ' ' +
+        vendorsPrefixes.join(propUC + ' ') +
+        propUC
+      ).split(' ');
+    each(props, function(p) {
+      if (p in style) {
+        prefixedProps[prop] = p;
+        return false;
+      }
+    });
+  }
+
+  return prefixedProps[prop];
+}
+
+cash.prefixedProp = getPrefixedProp; // @require core/type_checking.js
+// @require ./is_css_variable.js
+
+var numericProps = {
+  animationIterationCount: true,
+  columnCount: true,
+  flexGrow: true,
+  flexShrink: true,
+  fontWeight: true,
+  lineHeight: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  widows: true,
+  zIndex: true
+};
+
+function getSuffixedValue(prop, value, isVariable) {
+  if (isVariable === void 0) {
+    isVariable = isCSSVariable(prop);
+  }
+
+  return !isVariable && !numericProps[prop] && isNumeric(value)
+    ? value + 'px'
+    : value;
+} // @require core/cash.js
+// @require core/type_checking.js
+// @require collection/each.js
+// @require ./helpers/compute_style.js
+// @require ./helpers/get_prefixed_prop.js
+// @require ./helpers/get_suffixed_value.js
+// @require ./helpers/is_css_variable.js
+
+fn.css = function(prop, value) {
+  if (isString(prop)) {
+    var isVariable = isCSSVariable(prop);
+    prop = getPrefixedProp(prop, isVariable);
+    if (arguments.length < 2)
+      return this[0] && computeStyle(this[0], prop, isVariable);
+    if (!prop) return this;
+    value = getSuffixedValue(prop, value, isVariable);
+    return this.each(function(i, ele) {
+      if (ele.nodeType !== 1) return;
+
+      if (isVariable) {
+        ele.style.setProperty(prop, value);
+      } else {
+        ele.style[prop] = value;
+      }
+    });
+  }
+
+  for (var key in prop) {
+    this.css(key, prop[key]);
+  }
+
+  return this;
+}; // @optional ./css.js
+
+var dataNamespace = '__cashData',
+  dataAttributeRe = /^data-(.*)/; // @require core/cash.js
+// @require ./helpers/variables.js
+
+cash.hasData = function(ele) {
+  return dataNamespace in ele;
+}; // @require ./variables.js
+
+function getDataCache(ele) {
+  return (ele[dataNamespace] = ele[dataNamespace] || {});
+} // @require attributes/attr.js
+// @require ./get_data_cache.js
+
+function getData(ele, key) {
+  var cache = getDataCache(ele);
+
+  if (key) {
+    if (!(key in cache)) {
+      var value = ele.dataset
+        ? ele.dataset[key] || ele.dataset[camelCase(key)]
+        : cash(ele).attr('data-' + key);
+
+      if (value !== undefined) {
+        try {
+          value = JSON.parse(value);
+        } catch (e) {}
+
+        cache[key] = value;
+      }
+    }
+
+    return cache[key];
+  }
+
+  return cache;
+} // @require ./variables.js
+// @require ./get_data_cache.js
+
+function removeData(ele, key) {
+  if (key === undefined) {
+    delete ele[dataNamespace];
+  } else {
+    delete getDataCache(ele)[key];
+  }
+} // @require ./get_data_cache.js
+
+function setData(ele, key, value) {
+  getDataCache(ele)[key] = value;
+} // @require core/cash.js
+// @require core/type_checking.js
+// @require collection/each.js
+// @require ./helpers/get_data.js
+// @require ./helpers/set_data.js
+// @require ./helpers/variables.js
+
+fn.data = function(name, value) {
+  var _this = this;
+
+  if (!name) {
+    if (!this[0]) return;
+    each(this[0].attributes, function(attr) {
+      var match = attr.name.match(dataAttributeRe);
+      if (!match) return;
+
+      _this.data(match[1]);
+    });
+    return getData(this[0]);
+  }
+
+  if (isString(name)) {
+    if (value === undefined) return this[0] && getData(this[0], name);
+    return this.each(function(i, ele) {
+      return setData(ele, name, value);
+    });
+  }
+
+  for (var key in name) {
+    this.data(key, name[key]);
+  }
+
+  return this;
+}; // @require core/cash.js
+// @require collection/each.js
+// @require ./helpers/remove_data.js
+
+fn.removeData = function(key) {
+  return this.each(function(i, ele) {
+    return removeData(ele, key);
+  });
+}; // @optional ./data.js
+// @optional ./remove_data.js
+// @require css/helpers/compute_style_int.js
+
+function getExtraSpace(ele, xAxis) {
+  return (
+    computeStyleInt(ele, 'border' + (xAxis ? 'Left' : 'Top') + 'Width') +
+    computeStyleInt(ele, 'padding' + (xAxis ? 'Left' : 'Top')) +
+    computeStyleInt(ele, 'padding' + (xAxis ? 'Right' : 'Bottom')) +
+    computeStyleInt(ele, 'border' + (xAxis ? 'Right' : 'Bottom') + 'Width')
+  );
+} // @require core/cash.js
+// @require core/each.js
+// @require core/variables.js
+
+each(['Width', 'Height'], function(prop) {
+  fn['inner' + prop] = function() {
+    if (!this[0]) return;
+    if (this[0] === win) return win['inner' + prop];
+    return this[0]['client' + prop];
+  };
+}); // @require core/camel_case.js
+// @require core/cash.js
+// @require core/each.js
+// @require core/variables.js
+// @require css/helpers/compute_style.js
+// @require css/helpers/get_suffixed_value.js
+// @require ./helpers/get_extra_space.js
+
+each(['width', 'height'], function(prop, index) {
+  fn[prop] = function(value) {
+    if (!this[0]) return value === undefined ? undefined : this;
+
+    if (!arguments.length) {
+      if (this[0] === win) return this[0][camelCase('outer-' + prop)];
+      return (
+        this[0].getBoundingClientRect()[prop] - getExtraSpace(this[0], !index)
+      );
+    }
+
+    value = parseInt(value, 10);
+    return this.each(function(i, ele) {
+      if (ele.nodeType !== 1) return;
+      var boxSizing = computeStyle(ele, 'boxSizing');
+      ele.style[prop] = getSuffixedValue(
+        prop,
+        value + (boxSizing === 'border-box' ? getExtraSpace(ele, !index) : 0)
+      );
+    });
+  };
+}); // @require core/cash.js
+// @require core/each.js
+// @require core/variables.js
+// @require css/helpers/compute_style_int.js
+
+each(['Width', 'Height'], function(prop, index) {
+  fn['outer' + prop] = function(includeMargins) {
+    if (!this[0]) return;
+    if (this[0] === win) return win['outer' + prop];
+    return (
+      this[0]['offset' + prop] +
+      (includeMargins
+        ? computeStyleInt(this[0], 'margin' + (!index ? 'Left' : 'Top')) +
+          computeStyleInt(this[0], 'margin' + (!index ? 'Right' : 'Bottom'))
+        : 0)
+    );
+  };
+}); // @optional ./inner.js
+// @optional ./normal.js
+// @optional ./outer.js
+
+function hasNamespaces(ns1, ns2) {
+  for (var i = 0, l = ns2.length; i < l; i++) {
+    if (ns1.indexOf(ns2[i]) < 0) return false;
+  }
+
+  return true;
+} // @require core/each.js
+
+function removeEventListeners(cache, ele, name) {
+  each(cache[name], function(_ref) {
+    var namespaces = _ref[0],
+      callback = _ref[1];
+    ele.removeEventListener(name, callback);
+  });
+  delete cache[name];
+}
+
+var eventsNamespace = '__cashEvents',
+  eventsNamespacesSeparator = '.'; // @require ./variables.js
+
+function getEventsCache(ele) {
+  return (ele[eventsNamespace] = ele[eventsNamespace] || {});
+} // @require core/guid.js
+// @require events/helpers/get_events_cache.js
+
+function addEvent(ele, name, namespaces, callback) {
+  callback.guid = callback.guid || guid++;
+  var eventCache = getEventsCache(ele);
+  eventCache[name] = eventCache[name] || [];
+  eventCache[name].push([namespaces, callback]);
+  ele.addEventListener(name, callback);
+} // @require ./variables.js
+
+function parseEventName(eventName) {
+  var parts = eventName.split(eventsNamespacesSeparator);
+  return [parts[0], parts.slice(1).sort()]; // [name, namespaces]
+} // @require core/guid.js
+// @require ./get_events_cache.js
+// @require ./has_namespaces.js
+// @require ./parse_event_name.js
+// @require ./remove_event_listeners.js
+
+function removeEvent(ele, name, namespaces, callback) {
+  var cache = getEventsCache(ele);
+
+  if (!name) {
+    if (!namespaces || !namespaces.length) {
+      for (name in cache) {
+        removeEventListeners(cache, ele, name);
+      }
+    } else {
+      for (name in cache) {
+        removeEvent(ele, name, namespaces, callback);
+      }
+    }
+  } else {
+    var eventCache = cache[name];
+    if (!eventCache) return;
+    if (callback) callback.guid = callback.guid || guid++;
+    cache[name] = eventCache.filter(function(_ref2) {
+      var ns = _ref2[0],
+        cb = _ref2[1];
+      if (
+        (callback && cb.guid !== callback.guid) ||
+        !hasNamespaces(ns, namespaces)
+      )
+        return true;
+      ele.removeEventListener(name, cb);
+    });
+  }
+} // @require core/cash.js
+// @require core/each.js
+// @require collection/each.js
+// @require ./helpers/parse_event_name.js
+// @require ./helpers/remove_event.js
+
+fn.off = function(eventFullName, callback) {
+  var _this2 = this;
+
+  if (eventFullName === undefined) {
+    this.each(function(i, ele) {
+      return removeEvent(ele);
+    });
+  } else {
+    each(getSplitValues(eventFullName), function(eventFullName) {
+      var _parseEventName = parseEventName(eventFullName),
+        name = _parseEventName[0],
+        namespaces = _parseEventName[1];
+
+      _this2.each(function(i, ele) {
+        return removeEvent(ele, name, namespaces, callback);
+      });
+    });
+  }
+
+  return this;
+}; // @require core/cash.js
+// @require core/get_split_values.js
+// @require core/guid.js
+// @require core/matches.js
+// @require core/type_checking.js
+// @require collection/each.js
+// @require ./helpers/variables.js
+// @require ./helpers/add_event.js
+// @require ./helpers/has_namespaces.js
+// @require ./helpers/parse_event_name.js
+// @require ./helpers/remove_event.js
+
+fn.on = function(eventFullName, selector, callback, _one) {
+  var _this3 = this;
+
+  if (!isString(eventFullName)) {
+    for (var key in eventFullName) {
+      this.on(key, selector, eventFullName[key]);
+    }
+
+    return this;
+  }
+
+  if (isFunction(selector)) {
+    callback = selector;
+    selector = false;
+  }
+
+  each(getSplitValues(eventFullName), function(eventFullName) {
+    var _parseEventName2 = parseEventName(eventFullName),
+      name = _parseEventName2[0],
+      namespaces = _parseEventName2[1];
+
+    _this3.each(function(i, ele) {
+      var finalCallback = function finalCallback(event) {
+        if (
+          event.namespace &&
+          !hasNamespaces(
+            namespaces,
+            event.namespace.split(eventsNamespacesSeparator)
+          )
+        )
+          return;
+        var thisArg = ele;
+
+        if (selector) {
+          var target = event.target;
+
+          while (!matches(target, selector)) {
+            if (target === ele) return;
+            target = target.parentNode;
+            if (!target) return;
+          }
+
+          thisArg = target;
+        }
+
+        event.namespace = event.namespace || '';
+        var returnValue = callback.call(thisArg, event, event.data);
+
+        if (_one) {
+          removeEvent(ele, name, namespaces, finalCallback);
+        }
+
+        if (returnValue === false) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      };
+
+      finalCallback.guid = callback.guid = callback.guid || guid++;
+      addEvent(ele, name, namespaces, finalCallback);
+    });
+  });
+  return this;
+}; // @require core/cash.js
+// @require ./on.js
+
+fn.one = function(eventFullName, delegate, callback) {
+  return this.on(eventFullName, delegate, callback, true);
+}; // @require core/cash.js
+// @require core/variables.js
+
+fn.ready = function(callback) {
+  var finalCallback = function finalCallback() {
+    return callback(cash);
+  };
+
+  if (doc.readyState !== 'loading') {
+    setTimeout(finalCallback);
+  } else {
+    doc.addEventListener('DOMContentLoaded', finalCallback);
+  }
+
+  return this;
+}; // @require core/cash.js
+// @require core/type_checking.js
+// @require core/variables.js
+// @require collection/each.js
+// @require ./helpers/parse_event_name.js
+// @require ./helpers/variables.js
+
+fn.trigger = function(eventFullName, data) {
+  var evt = eventFullName;
+
+  if (isString(eventFullName)) {
+    var _parseEventName3 = parseEventName(eventFullName),
+      name = _parseEventName3[0],
+      namespaces = _parseEventName3[1];
+
+    evt = doc.createEvent('HTMLEvents');
+    evt.initEvent(name, true, true);
+    evt.namespace = namespaces.join(eventsNamespacesSeparator);
+  }
+
+  evt.data = data;
+  return this.each(function(i, ele) {
+    ele.dispatchEvent(evt);
+  });
+}; // @optional ./off.js
+// @optional ./on.js
+// @optional ./one.js
+// @optional ./ready.js
+// @optional ./trigger.js
+// @require core/each.js
+
+function getValueSelectMultiple(ele) {
+  var values = [];
+  each(ele.options, function(option) {
+    if (option.selected && !option.disabled && !option.parentNode.disabled) {
+      values.push(option.value);
+    }
+  });
+  return values;
+}
+
+function getValueSelectSingle(ele) {
+  return ele.selectedIndex < 0 ? null : ele.options[ele.selectedIndex].value;
+} // @require ./get_value_select_single.js
+// @require ./get_value_select_multiple.js
+
+var selectOneRe = /select-one/i,
+  selectMultipleRe = /select-multiple/i;
+
+function getValue(ele) {
+  var type = ele.type;
+  if (selectOneRe.test(type)) return getValueSelectSingle(ele);
+  if (selectMultipleRe.test(type)) return getValueSelectMultiple(ele);
+  return ele.value;
+}
+
+var queryEncodeSpaceRe = /%20/g;
+
+function queryEncode(prop, value) {
+  return (
+    '&' +
+    encodeURIComponent(prop) +
+    '=' +
+    encodeURIComponent(value).replace(queryEncodeSpaceRe, '+')
+  );
+} // @require core/cash.js
+// @require core/each.js
+// @require core/type_checking.js
+// @require ./helpers/get_value.js
+// @require ./helpers/query_encode.js
+
+var skippableRe = /file|reset|submit|button|image/i,
+  checkableRe = /radio|checkbox/i;
+
+fn.serialize = function() {
+  var query = '';
+  this.each(function(i, ele) {
+    each(ele.elements || [ele], function(ele) {
+      if (ele.disabled || !ele.name || ele.tagName === 'FIELDSET') return;
+      if (skippableRe.test(ele.type)) return;
+      if (checkableRe.test(ele.type) && !ele.checked) return;
+      var value = getValue(ele);
+      if (value === undefined) return;
+      var values = isArray(value) ? value : [value];
+      each(values, function(value) {
+        query += queryEncode(ele.name, value);
+      });
+    });
+  });
+  return query.substr(1);
+}; // @require core/cash.js
+// @require core/each.js
+// @require core/type_checking.js
+// @require collection/each.js
+// @require ./helpers/get_value.js
+
+fn.val = function(value) {
+  if (value === undefined) return this[0] && getValue(this[0]);
+  return this.each(function(i, ele) {
+    var isMultiple = selectMultipleRe.test(ele.type),
+      eleValue = value === null ? (isMultiple ? [] : '') : value;
+
+    if (isMultiple && isArray(eleValue)) {
+      each(ele.options, function(option) {
+        option.selected = eleValue.indexOf(option.value) >= 0;
+      });
+    } else {
+      ele.value = eleValue;
+    }
+  });
+}; // @optional ./serialize.js
+// @optional ./val.js
+// @require core/cash.js
+// @require collection/map.js
+
+fn.clone = function() {
+  return this.map(function(i, ele) {
+    return ele.cloneNode(true);
+  });
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.detach = function() {
+  return this.each(function(i, ele) {
+    if (ele.parentNode) {
+      ele.parentNode.removeChild(ele);
+    }
+  });
+}; // @require ./cash.js
+// @require ./variables.js
+// @require ./type_checking.js
+// @require collection/get.js
+// @require manipulation/detach.js
+
+var fragmentRe = /^\s*<(\w+)[^>]*>/,
+  singleTagRe = /^\s*<(\w+)\s*\/?>(?:<\/\1>)?\s*$/;
+var containers;
+
+function initContainers() {
+  if (containers) return;
+  var table = doc.createElement('table'),
+    tr = doc.createElement('tr');
+  containers = {
+    '*': doc.createElement('div'),
+    tr: doc.createElement('tbody'),
+    td: tr,
+    th: tr,
+    thead: table,
+    tbody: table,
+    tfoot: table
+  };
+}
+
+function parseHTML(html) {
+  initContainers();
+  if (!isString(html)) return [];
+  if (singleTagRe.test(html)) return [doc.createElement(RegExp.$1)];
+  var fragment = fragmentRe.test(html) && RegExp.$1,
+    container = containers[fragment] || containers['*'];
+  container.innerHTML = html;
+  return cash(container.childNodes)
+    .detach()
+    .get();
+}
+
+cash.parseHTML = parseHTML; // @optional ./camel_case.js
+// @optional ./each.js
+// @optional ./export.js
+// @optional ./extend.js
+// @optional ./find.js
+// @optional ./get_compare_function.js
+// @optional ./get_split_values.js
+// @optional ./guid.js
+// @optional ./matches.js
+// @optional ./parse_html.js
+// @optional ./unique.js
+// @optional ./variables.js
+// @require ./cash.js
+// @require ./type_checking.js
+// @require core/cash.js
+
+fn.empty = function() {
+  var ele = this[0];
+
+  if (ele) {
+    while (ele.firstChild) {
+      ele.removeChild(ele.firstChild);
+    }
+  }
+
+  return this;
+};
+
+function insertElement(ele, child, prepend) {
+  if (prepend) {
+    ele.insertBefore(child, ele.childNodes[0]);
+  } else {
+    ele.appendChild(child);
+  }
+} // @require core/each.js
+// @require core/type_checking.js
+// @require ./insert_element.js
+
+function insertContent(parent, child, prepend) {
+  if (child === undefined) return;
+  var isStr = isString(child);
+
+  if (!isStr && child.length) {
+    each(child, function(ele) {
+      return insertContent(parent, ele, prepend);
+    });
+  } else {
+    each(
+      parent,
+      isStr
+        ? function(ele) {
+            ele.insertAdjacentHTML(prepend ? 'afterbegin' : 'beforeend', child);
+          }
+        : function(ele, index) {
+            return insertElement(
+              ele,
+              !index ? child : child.cloneNode(true),
+              prepend
+            );
+          }
+    );
+  }
+} // @require core/cash.js
+// @require core/each.js
+// @require ./helpers/insert_content.js
+
+fn.append = function() {
+  var _this4 = this;
+
+  each(arguments, function(content) {
+    insertContent(_this4, content);
+  });
+  return this;
+}; // @require core/cash.js
+// @require ./helpers/insert_content.js
+
+fn.appendTo = function(parent) {
+  insertContent(cash(parent), this);
+  return this;
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.html = function(content) {
+  if (content === undefined) return this[0] && this[0].innerHTML;
+  var source = content.nodeType ? content[0].outerHTML : content;
+  return this.each(function(i, ele) {
+    ele.innerHTML = source;
+  });
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.insertAfter = function(content) {
+  var _this5 = this;
+
+  cash(content).each(function(index, ele) {
+    var parent = ele.parentNode;
+
+    _this5.each(function(i, e) {
+      parent.insertBefore(!index ? e : e.cloneNode(true), ele.nextSibling);
+    });
+  });
+  return this;
+}; // @require core/cash.js
+// @require core/each.js
+// @require core/variables.js
+// @require collection/slice.js
+// @require ./insert_after.js
+
+fn.after = function() {
+  var _this6 = this;
+
+  each(reverse.apply(arguments), function(content) {
+    reverse.apply(cash(content).slice()).insertAfter(_this6);
+  });
+  return this;
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.insertBefore = function(selector) {
+  var _this7 = this;
+
+  cash(selector).each(function(index, ele) {
+    var parent = ele.parentNode;
+
+    _this7.each(function(i, e) {
+      parent.insertBefore(!index ? e : e.cloneNode(true), ele);
+    });
+  });
+  return this;
+}; // @require core/cash.js
+// @require core/each.js
+// @require ./insert_before.js
+
+fn.before = function() {
+  var _this8 = this;
+
+  each(arguments, function(content) {
+    cash(content).insertBefore(_this8);
+  });
+  return this;
+}; // @require core/cash.js
+// @require core/each.js
+// @require ./helpers/insert_content.js
+
+fn.prepend = function() {
+  var _this9 = this;
+
+  each(arguments, function(content) {
+    insertContent(_this9, content, true);
+  });
+  return this;
+}; // @require core/cash.js
+// @require core/variables.js
+// @require collection/slice.js
+// @require ./helpers/insert_content.js
+
+fn.prependTo = function(parent) {
+  insertContent(cash(parent), reverse.apply(this.slice()), true);
+  return this;
+}; // @require core/cash.js
+// @require events/off.js
+// @require ./detach.js
+
+fn.remove = function() {
+  return this.detach().off();
+}; // @require core/cash.js
+// @require collection/each.js
+// @require collection/slice.js
+// @require ./after.js
+// @require ./remove.js
+
+fn.replaceWith = function(content) {
+  var _this10 = this;
+
+  return this.each(function(i, ele) {
+    var parent = ele.parentNode;
+    if (!parent) return;
+    var $eles = i ? cash(content).clone() : cash(content);
+
+    if (!$eles[0]) {
+      _this10.remove();
+
+      return false;
+    }
+
+    parent.replaceChild($eles[0], ele);
+    cash($eles[0]).after($eles.slice(1));
+  });
+}; // @require core/cash.js
+// @require ./replace_with.js
+
+fn.replaceAll = function(content) {
+  cash(content).replaceWith(this);
+  return this;
+}; // @require core/cash.js
+// @require collection/each.js
+
+fn.text = function(content) {
+  if (content === undefined) return this[0] ? this[0].textContent : '';
+  return this.each(function(i, ele) {
+    ele.textContent = content;
+  });
+}; // @optional ./after.js
+// @optional ./append.js
+// @optional ./append_to.js
+// @optional ./before.js
+// @optional ./clone.js
+// @optional ./detach.js
+// @optional ./empty.js
+// @optional ./html.js
+// @optional ./insert_after.js
+// @optional ./insert_before.js
+// @optional ./prepend.js
+// @optional ./prepend_to.js
+// @optional ./remove.js
+// @optional ./replace_all.js
+// @optional ./replace_with.js
+// @optional ./text.js
+// @require core/cash.js
+// @require core/variables.js
+
+var docEle = doc.documentElement;
+
+fn.offset = function() {
+  var ele = this[0];
+  if (!ele) return;
+  var rect = ele.getBoundingClientRect();
+  return {
+    top: rect.top + win.pageYOffset - docEle.clientTop,
+    left: rect.left + win.pageXOffset - docEle.clientLeft
+  };
+}; // @require core/cash.js
+
+fn.offsetParent = function() {
+  return cash(this[0] && this[0].offsetParent);
+}; // @require core/cash.js
+
+fn.position = function() {
+  var ele = this[0];
+  if (!ele) return;
+  return {
+    left: ele.offsetLeft,
+    top: ele.offsetTop
+  };
+}; // @optional ./offset.js
+// @optional ./offset_parent.js
+// @optional ./position.js
+// @require core/cash.js
+// @require core/matches.js
+// @require core/unique.js
+// @require collection/each.js
+// @require collection/filter.js
+
+fn.children = function(selector) {
+  var result = [];
+  this.each(function(i, ele) {
+    push.apply(result, ele.children);
+  });
+  result = cash(unique(result));
+  if (!selector) return result;
+  return result.filter(function(i, ele) {
+    return matches(ele, selector);
+  });
+}; // @require core/cash.js
+// @require core/unique.js
+// @require collection/each.js
+
+fn.contents = function() {
+  var result = [];
+  this.each(function(i, ele) {
+    push.apply(
+      result,
+      ele.tagName === 'IFRAME' ? [ele.contentDocument] : ele.childNodes
+    );
+  });
+  return cash(result.length && unique(result));
+}; // @require core/cash.js
+// @require core/unique.js
+// @require core/find.js
+// @require core/variables.js
+
+fn.find = function(selector) {
+  var result = [];
+
+  for (var i = 0, l = this.length; i < l; i++) {
+    var found = find(selector, this[i]);
+
+    if (found.length) {
+      push.apply(result, found);
+    }
+  }
+
+  return cash(result.length && unique(result));
+}; // @require core/cash.js
+// @require core/find.js
+// @require core/type_checking.js
+// @require collection/filter.js
+
+fn.has = function(selector) {
+  var comparator = isString(selector)
+    ? function(i, ele) {
+        return !!find(selector, ele).length;
+      }
+    : function(i, ele) {
+        return ele.contains(selector);
+      };
+  return this.filter(comparator);
+}; // @require core/cash.js
+// @require core/get_compare_function.js
+// @require collection/each.js
+
+fn.is = function(selector) {
+  if (!selector || !this[0]) return false;
+  var comparator = getCompareFunction(selector);
+  var check = false;
+  this.each(function(i, ele) {
+    check = comparator(i, ele, selector);
+    return !check;
+  });
+  return check;
+}; // @require core/cash.js
+
+fn.next = function() {
+  return cash(this[0] && this[0].nextElementSibling);
+}; // @require core/cash.js
+// @require core/get_compare_function.js
+// @require collection/filter.js
+
+fn.not = function(selector) {
+  if (!selector || !this[0]) return this;
+  var comparator = getCompareFunction(selector);
+  return this.filter(function(i, ele) {
+    return !comparator(i, ele, selector);
+  });
+}; // @require core/cash.js
+// @require core/unique.js
+// @require collection/each.js
+
+fn.parent = function() {
+  var result = [];
+  this.each(function(i, ele) {
+    if (ele && ele.parentNode) {
+      result.push(ele.parentNode);
+    }
+  });
+  return cash(unique(result));
+}; // @require core/cash.js
+// @require core/variables.js
+// @require traversal/children.js
+// @require traversal/parent.js
+// @require ./get.js
+//FIXME Ugly file name, is there a better option?
+
+fn.index = function(ele) {
+  var child = ele ? cash(ele)[0] : this[0],
+    collection = ele
+      ? this
+      : cash(child)
+          .parent()
+          .children();
+  return indexOf.call(collection, child);
+}; // @optional ./add.js
+// @optional ./each.js
+// @optional ./eq.js
+// @optional ./filter.js
+// @optional ./first.js
+// @optional ./get.js
+// @optional ./indexFn.js
+// @optional ./last.js
+// @optional ./map.js
+// @optional ./slice.js
+// @require core/cash.js
+// @require collection/filter.js
+// @require ./is.js
+// @require ./parent.js
+
+fn.closest = function(selector) {
+  if (!selector || !this[0]) return cash();
+  if (this.is(selector)) return this.filter(selector);
+  return this.parent().closest(selector);
+}; // @require core/cash.js
+// @require core/matches.js
+// @require core/unique.js
+// @require core/variables.js
+// @require collection/each.js
+
+fn.parents = function(selector) {
+  var result = [];
+  var last;
+  this.each(function(i, ele) {
+    last = ele;
+
+    while (last && last.parentNode && last !== doc.body.parentNode) {
+      last = last.parentNode;
+
+      if (!selector || (selector && matches(last, selector))) {
+        result.push(last);
+      }
+    }
+  });
+  return cash(unique(result));
+}; // @require core/cash.js
+
+fn.prev = function() {
+  return cash(this[0] && this[0].previousElementSibling);
+}; // @require core/cash.js
+// @require collection/filter.js
+// @require ./children.js
+// @require ./parent.js
+
+fn.siblings = function() {
+  var ele = this[0];
+  return this.parent()
+    .children()
+    .filter(function(i, child) {
+      return child !== ele;
+    });
+}; // @optional ./children.js
+// @optional ./closest.js
+// @optional ./contents.js
+// @optional ./find.js
+// @optional ./has.js
+// @optional ./is.js
+// @optional ./next.js
+// @optional ./not.js
+// @optional ./parent.js
+// @optional ./parents.js
+// @optional ./prev.js
+// @optional ./siblings.js
+// @optional attributes/index.js
+// @optional collection/index.js
+// @optional css/index.js
+// @optional data/index.js
+// @optional dimensions/index.js
+// @optional events/index.js
+// @optional forms/index.js
+// @optional manipulation/index.js
+// @optional offset/index.js
+// @optional traversal/index.js
+// @require core/index.js
+export default cash;