/*!
 * mdui 1.0.2 (https://mdui.org)
 * Copyright 2016-2021 zdhxiong
 * Licensed under MIT
 */
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.mdui = factory());
}(this, (function () { 'use strict';

  !function(){try{return new MouseEvent("test")}catch(e$1){}var e=function(e,t){t=t||{bubbles:!1,cancelable:!1};var n=document.createEvent("MouseEvent");return n.initMouseEvent(e,t.bubbles,t.cancelable,window,0,t.screenX||0,t.screenY||0,t.clientX||0,t.clientY||0,t.ctrlKey||!1,t.altKey||!1,t.shiftKey||!1,t.metaKey||!1,t.button||0,t.relatedTarget||null),n};e.prototype=Event.prototype,window.MouseEvent=e;}();

  !function(){function t(t,e){e=e||{bubbles:!1,cancelable:!1,detail:void 0};var n=document.createEvent("CustomEvent");return n.initCustomEvent(t,e.bubbles,e.cancelable,e.detail),n}"function"!=typeof window.CustomEvent&&(t.prototype=window.Event.prototype,window.CustomEvent=t);}();

  /**
   * @this {Promise}
   */
  function finallyConstructor(callback) {
    var constructor = this.constructor;
    return this.then(
      function(value) {
        // @ts-ignore
        return constructor.resolve(callback()).then(function() {
          return value;
        });
      },
      function(reason) {
        // @ts-ignore
        return constructor.resolve(callback()).then(function() {
          // @ts-ignore
          return constructor.reject(reason);
        });
      }
    );
  }

  function allSettled(arr) {
    var P = this;
    return new P(function(resolve, reject) {
      if (!(arr && typeof arr.length !== 'undefined')) {
        return reject(
          new TypeError(
            typeof arr +
              ' ' +
              arr +
              ' is not iterable(cannot read property Symbol(Symbol.iterator))'
          )
        );
      }
      var args = Array.prototype.slice.call(arr);
      if (args.length === 0) { return resolve([]); }
      var remaining = args.length;

      function res(i, val) {
        if (val && (typeof val === 'object' || typeof val === 'function')) {
          var then = val.then;
          if (typeof then === 'function') {
            then.call(
              val,
              function(val) {
                res(i, val);
              },
              function(e) {
                args[i] = { status: 'rejected', reason: e };
                if (--remaining === 0) {
                  resolve(args);
                }
              }
            );
            return;
          }
        }
        args[i] = { status: 'fulfilled', value: val };
        if (--remaining === 0) {
          resolve(args);
        }
      }

      for (var i = 0; i < args.length; i++) {
        res(i, args[i]);
      }
    });
  }

  // Store setTimeout reference so promise-polyfill will be unaffected by
  // other code modifying setTimeout (like sinon.useFakeTimers())
  var setTimeoutFunc = setTimeout;

  function isArray(x) {
    return Boolean(x && typeof x.length !== 'undefined');
  }

  function noop() {}

  // Polyfill for Function.prototype.bind
  function bind(fn, thisArg) {
    return function() {
      fn.apply(thisArg, arguments);
    };
  }

  /**
   * @constructor
   * @param {Function} fn
   */
  function Promise$1(fn) {
    if (!(this instanceof Promise$1))
      { throw new TypeError('Promises must be constructed via new'); }
    if (typeof fn !== 'function') { throw new TypeError('not a function'); }
    /** @type {!number} */
    this._state = 0;
    /** @type {!boolean} */
    this._handled = false;
    /** @type {Promise|undefined} */
    this._value = undefined;
    /** @type {!Array<!Function>} */
    this._deferreds = [];

    doResolve(fn, this);
  }

  function handle(self, deferred) {
    while (self._state === 3) {
      self = self._value;
    }
    if (self._state === 0) {
      self._deferreds.push(deferred);
      return;
    }
    self._handled = true;
    Promise$1._immediateFn(function() {
      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
      if (cb === null) {
        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
        return;
      }
      var ret;
      try {
        ret = cb(self._value);
      } catch (e) {
        reject(deferred.promise, e);
        return;
      }
      resolve(deferred.promise, ret);
    });
  }

  function resolve(self, newValue) {
    try {
      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
      if (newValue === self)
        { throw new TypeError('A promise cannot be resolved with itself.'); }
      if (
        newValue &&
        (typeof newValue === 'object' || typeof newValue === 'function')
      ) {
        var then = newValue.then;
        if (newValue instanceof Promise$1) {
          self._state = 3;
          self._value = newValue;
          finale(self);
          return;
        } else if (typeof then === 'function') {
          doResolve(bind(then, newValue), self);
          return;
        }
      }
      self._state = 1;
      self._value = newValue;
      finale(self);
    } catch (e) {
      reject(self, e);
    }
  }

  function reject(self, newValue) {
    self._state = 2;
    self._value = newValue;
    finale(self);
  }

  function finale(self) {
    if (self._state === 2 && self._deferreds.length === 0) {
      Promise$1._immediateFn(function() {
        if (!self._handled) {
          Promise$1._unhandledRejectionFn(self._value);
        }
      });
    }

    for (var i = 0, len = self._deferreds.length; i < len; i++) {
      handle(self, self._deferreds[i]);
    }
    self._deferreds = null;
  }

  /**
   * @constructor
   */
  function Handler(onFulfilled, onRejected, promise) {
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
    this.promise = promise;
  }

  /**
   * Take a potentially misbehaving resolver function and make sure
   * onFulfilled and onRejected are only called once.
   *
   * Makes no guarantees about asynchrony.
   */
  function doResolve(fn, self) {
    var done = false;
    try {
      fn(
        function(value) {
          if (done) { return; }
          done = true;
          resolve(self, value);
        },
        function(reason) {
          if (done) { return; }
          done = true;
          reject(self, reason);
        }
      );
    } catch (ex) {
      if (done) { return; }
      done = true;
      reject(self, ex);
    }
  }

  Promise$1.prototype['catch'] = function(onRejected) {
    return this.then(null, onRejected);
  };

  Promise$1.prototype.then = function(onFulfilled, onRejected) {
    // @ts-ignore
    var prom = new this.constructor(noop);

    handle(this, new Handler(onFulfilled, onRejected, prom));
    return prom;
  };

  Promise$1.prototype['finally'] = finallyConstructor;

  Promise$1.all = function(arr) {
    return new Promise$1(function(resolve, reject) {
      if (!isArray(arr)) {
        return reject(new TypeError('Promise.all accepts an array'));
      }

      var args = Array.prototype.slice.call(arr);
      if (args.length === 0) { return resolve([]); }
      var remaining = args.length;

      function res(i, val) {
        try {
          if (val && (typeof val === 'object' || typeof val === 'function')) {
            var then = val.then;
            if (typeof then === 'function') {
              then.call(
                val,
                function(val) {
                  res(i, val);
                },
                reject
              );
              return;
            }
          }
          args[i] = val;
          if (--remaining === 0) {
            resolve(args);
          }
        } catch (ex) {
          reject(ex);
        }
      }

      for (var i = 0; i < args.length; i++) {
        res(i, args[i]);
      }
    });
  };

  Promise$1.allSettled = allSettled;

  Promise$1.resolve = function(value) {
    if (value && typeof value === 'object' && value.constructor === Promise$1) {
      return value;
    }

    return new Promise$1(function(resolve) {
      resolve(value);
    });
  };

  Promise$1.reject = function(value) {
    return new Promise$1(function(resolve, reject) {
      reject(value);
    });
  };

  Promise$1.race = function(arr) {
    return new Promise$1(function(resolve, reject) {
      if (!isArray(arr)) {
        return reject(new TypeError('Promise.race accepts an array'));
      }

      for (var i = 0, len = arr.length; i < len; i++) {
        Promise$1.resolve(arr[i]).then(resolve, reject);
      }
    });
  };

  // Use polyfill for setImmediate for performance gains
  Promise$1._immediateFn =
    // @ts-ignore
    (typeof setImmediate === 'function' &&
      function(fn) {
        // @ts-ignore
        setImmediate(fn);
      }) ||
    function(fn) {
      setTimeoutFunc(fn, 0);
    };

  Promise$1._unhandledRejectionFn = function _unhandledRejectionFn(err) {
    if (typeof console !== 'undefined' && console) {
      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
    }
  };

  /** @suppress {undefinedVars} */
  var globalNS = (function() {
    // the only reliable means to get the global object is
    // `Function('return this')()`
    // However, this causes CSP violations in Chrome apps.
    if (typeof self !== 'undefined') {
      return self;
    }
    if (typeof window !== 'undefined') {
      return window;
    }
    if (typeof global !== 'undefined') {
      return global;
    }
    throw new Error('unable to locate global object');
  })();

  // Expose the polyfill if Promise is undefined or set to a
  // non-function value. The latter can be due to a named HTMLElement
  // being exposed by browsers for legacy reasons.
  // https://github.com/taylorhakes/promise-polyfill/issues/114
  if (typeof globalNS['Promise'] !== 'function') {
    globalNS['Promise'] = Promise$1;
  } else if (!globalNS.Promise.prototype['finally']) {
    globalNS.Promise.prototype['finally'] = finallyConstructor;
  } else if (!globalNS.Promise.allSettled) {
    globalNS.Promise.allSettled = allSettled;
  }

  function isFunction(target) {
      return typeof target === 'function';
  }
  function isString(target) {
      return typeof target === 'string';
  }
  function isNumber(target) {
      return typeof target === 'number';
  }
  function isBoolean(target) {
      return typeof target === 'boolean';
  }
  function isUndefined(target) {
      return typeof target === 'undefined';
  }
  function isNull(target) {
      return target === null;
  }
  function isWindow(target) {
      return target instanceof Window;
  }
  function isDocument(target) {
      return target instanceof Document;
  }
  function isElement(target) {
      return target instanceof Element;
  }
  function isNode(target) {
      return target instanceof Node;
  }
  /**
   * 是否是 IE 浏览器
   */
  function isIE() {
      // @ts-ignore
      return !!window.document.documentMode;
  }
  function isArrayLike(target) {
      if (isFunction(target) || isWindow(target)) {
          return false;
      }
      return isNumber(target.length);
  }
  function isObjectLike(target) {
      return typeof target === 'object' && target !== null;
  }
  function toElement(target) {
      return isDocument(target) ? target.documentElement : target;
  }
  /**
   * 把用 - 分隔的字符串转为驼峰（如 box-sizing 转换为 boxSizing）
   * @param string
   */
  function toCamelCase(string) {
      return string
          .replace(/^-ms-/, 'ms-')
          .replace(/-([a-z])/g, function (_, letter) { return letter.toUpperCase(); });
  }
  /**
   * 把驼峰法转为用 - 分隔的字符串（如 boxSizing 转换为 box-sizing）
   * @param string
   */
  function toKebabCase(string) {
      return string.replace(/[A-Z]/g, function (replacer) { return '-' + replacer.toLowerCase(); });
  }
  /**
   * 获取元素的样式值
   * @param element
   * @param name
   */
  function getComputedStyleValue(element, name) {
      return window.getComputedStyle(element).getPropertyValue(toKebabCase(name));
  }
  /**
   * 检查元素的 box-sizing 是否是 border-box
   * @param element
   */
  function isBorderBox(element) {
      return getComputedStyleValue(element, 'box-sizing') === 'border-box';
  }
  /**
   * 获取元素的 padding, border, margin 宽度（两侧宽度的和，单位为px）
   * @param element
   * @param direction
   * @param extra
   */
  function getExtraWidth(element, direction, extra) {
      var position = direction === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
      return [0, 1].reduce(function (prev, _, index) {
          var prop = extra + position[index];
          if (extra === 'border') {
              prop += 'Width';
          }
          return prev + parseFloat(getComputedStyleValue(element, prop) || '0');
      }, 0);
  }
  /**
   * 获取元素的样式值，对 width 和 height 进行过处理
   * @param element
   * @param name
   */
  function getStyle(element, name) {
      // width、height 属性使用 getComputedStyle 得到的值不准确，需要使用 getBoundingClientRect 获取
      if (name === 'width' || name === 'height') {
          var valueNumber = element.getBoundingClientRect()[name];
          if (isBorderBox(element)) {
              return (valueNumber + "px");
          }
          return ((valueNumber -
              getExtraWidth(element, name, 'border') -
              getExtraWidth(element, name, 'padding')) + "px");
      }
      return getComputedStyleValue(element, name);
  }
  /**
   * 获取子节点组成的数组
   * @param target
   * @param parent
   */
  function getChildNodesArray(target, parent) {
      var tempParent = document.createElement(parent);
      tempParent.innerHTML = target;
      return [].slice.call(tempParent.childNodes);
  }
  /**
   * 始终返回 false 的函数
   */
  function returnFalse() {
      return false;
  }
  /**
   * 数值单位的 CSS 属性
   */
  var cssNumber = [
      'animationIterationCount',
      'columnCount',
      'fillOpacity',
      'flexGrow',
      'flexShrink',
      'fontWeight',
      'gridArea',
      'gridColumn',
      'gridColumnEnd',
      'gridColumnStart',
      'gridRow',
      'gridRowEnd',
      'gridRowStart',
      'lineHeight',
      'opacity',
      'order',
      'orphans',
      'widows',
      'zIndex',
      'zoom' ];

  function each(target, callback) {
      if (isArrayLike(target)) {
          for (var i = 0; i < target.length; i += 1) {
              if (callback.call(target[i], i, target[i]) === false) {
                  return target;
              }
          }
      }
      else {
          var keys = Object.keys(target);
          for (var i$1 = 0; i$1 < keys.length; i$1 += 1) {
              if (callback.call(target[keys[i$1]], keys[i$1], target[keys[i$1]]) === false) {
                  return target;
              }
          }
      }
      return target;
  }

  /**
   * 为了使用模块扩充，这里不能使用默认导出
   */
  var JQ = function JQ(arr) {
      var this$1 = this;

      this.length = 0;
      if (!arr) {
          return this;
      }
      each(arr, function (i, item) {
          // @ts-ignore
          this$1[i] = item;
      });
      this.length = arr.length;
      return this;
  };

  function get$() {
      var $ = function (selector) {
          if (!selector) {
              return new JQ();
          }
          // JQ
          if (selector instanceof JQ) {
              return selector;
          }
          // function
          if (isFunction(selector)) {
              if (/complete|loaded|interactive/.test(document.readyState) &&
                  document.body) {
                  selector.call(document, $);
              }
              else {
                  document.addEventListener('DOMContentLoaded', function () { return selector.call(document, $); }, false);
              }
              return new JQ([document]);
          }
          // String
          if (isString(selector)) {
              var html = selector.trim();
              // 根据 HTML 字符串创建 JQ 对象
              if (html[0] === '<' && html[html.length - 1] === '>') {
                  var toCreate = 'div';
                  var tags = {
                      li: 'ul',
                      tr: 'tbody',
                      td: 'tr',
                      th: 'tr',
                      tbody: 'table',
                      option: 'select',
                  };
                  each(tags, function (childTag, parentTag) {
                      if (html.indexOf(("<" + childTag)) === 0) {
                          toCreate = parentTag;
                          return false;
                      }
                      return;
                  });
                  return new JQ(getChildNodesArray(html, toCreate));
              }
              // 根据 CSS 选择器创建 JQ 对象
              var isIdSelector = selector[0] === '#' && !selector.match(/[ .<>:~]/);
              if (!isIdSelector) {
                  return new JQ(document.querySelectorAll(selector));
              }
              var element = document.getElementById(selector.slice(1));
              if (element) {
                  return new JQ([element]);
              }
              return new JQ();
          }
          if (isArrayLike(selector) && !isNode(selector)) {
              return new JQ(selector);
          }
          return new JQ([selector]);
      };
      $.fn = JQ.prototype;
      return $;
  }
  var $ = get$();

  // 避免页面加载完后直接执行css动画
  // https://css-tricks.com/transitions-only-after-page-load/
  setTimeout(function () { return $('body').addClass('mdui-loaded'); });
  var mdui = {
      $: $,
  };

  $.fn.each = function (callback) {
      return each(this, callback);
  };

  /**
   * 检查 container 元素内是否包含 contains 元素
   * @param container 父元素
   * @param contains 子元素
   * @example
  ```js
  contains( document, document.body ); // true
  contains( document.getElementById('test'), document ); // false
  contains( $('.container').get(0), $('.contains').get(0) ); // false
  ```
   */
  function contains(container, contains) {
      return container !== contains && toElement(container).contains(contains);
  }

  /**
   * 把第二个数组的元素追加到第一个数组中，并返回合并后的数组
   * @param first 第一个数组
   * @param second 该数组的元素将被追加到第一个数组中
   * @example
  ```js
  merge( [ 0, 1, 2 ], [ 2, 3, 4 ] )
  // [ 0, 1, 2, 2, 3, 4 ]
  ```
   */
  function merge(first, second) {
      each(second, function (_, value) {
          first.push(value);
      });
      return first;
  }

  $.fn.get = function (index) {
      return index === undefined
          ? [].slice.call(this)
          : this[index >= 0 ? index : index + this.length];
  };

  $.fn.find = function (selector) {
      var foundElements = [];
      this.each(function (_, element) {
          merge(foundElements, $(element.querySelectorAll(selector)).get());
      });
      return new JQ(foundElements);
  };

  // 存储事件
  var handlers = {};
  // 元素ID
  var mduiElementId = 1;
  /**
   * 为元素赋予一个唯一的ID
   */
  function getElementId(element) {
      var key = '_mduiEventId';
      // @ts-ignore
      if (!element[key]) {
          // @ts-ignore
          element[key] = ++mduiElementId;
      }
      // @ts-ignore
      return element[key];
  }
  /**
   * 解析事件名中的命名空间
   */
  function parse(type) {
      var parts = type.split('.');
      return {
          type: parts[0],
          ns: parts.slice(1).sort().join(' '),
      };
  }
  /**
   * 命名空间匹配规则
   */
  function matcherFor(ns) {
      return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)');
  }
  /**
   * 获取匹配的事件
   * @param element
   * @param type
   * @param func
   * @param selector
   */
  function getHandlers(element, type, func, selector) {
      var event = parse(type);
      return (handlers[getElementId(element)] || []).filter(function (handler) { return handler &&
          (!event.type || handler.type === event.type) &&
          (!event.ns || matcherFor(event.ns).test(handler.ns)) &&
          (!func || getElementId(handler.func) === getElementId(func)) &&
          (!selector || handler.selector === selector); });
  }
  /**
   * 添加事件监听
   * @param element
   * @param types
   * @param func
   * @param data
   * @param selector
   */
  function add(element, types, func, data, selector) {
      var elementId = getElementId(element);
      if (!handlers[elementId]) {
          handlers[elementId] = [];
      }
      // 传入 data.useCapture 来设置 useCapture: true
      var useCapture = false;
      if (isObjectLike(data) && data.useCapture) {
          useCapture = true;
      }
      types.split(' ').forEach(function (type) {
          if (!type) {
              return;
          }
          var event = parse(type);
          function callFn(e, elem) {
              // 因为鼠标事件模拟事件的 detail 属性是只读的，因此在 e._detail 中存储参数
              var result = func.apply(elem, 
              // @ts-ignore
              e._detail === undefined ? [e] : [e].concat(e._detail));
              if (result === false) {
                  e.preventDefault();
                  e.stopPropagation();
              }
          }
          function proxyFn(e) {
              // @ts-ignore
              if (e._ns && !matcherFor(e._ns).test(event.ns)) {
                  return;
              }
              // @ts-ignore
              e._data = data;
              if (selector) {
                  // 事件代理
                  $(element)
                      .find(selector)
                      .get()
                      .reverse()
                      .forEach(function (elem) {
                      if (elem === e.target ||
                          contains(elem, e.target)) {
                          callFn(e, elem);
                      }
                  });
              }
              else {
                  // 不使用事件代理
                  callFn(e, element);
              }
          }
          var handler = {
              type: event.type,
              ns: event.ns,
              func: func,
              selector: selector,
              id: handlers[elementId].length,
              proxy: proxyFn,
          };
          handlers[elementId].push(handler);
          element.addEventListener(handler.type, proxyFn, useCapture);
      });
  }
  /**
   * 移除事件监听
   * @param element
   * @param types
   * @param func
   * @param selector
   */
  function remove(element, types, func, selector) {
      var handlersInElement = handlers[getElementId(element)] || [];
      var removeEvent = function (handler) {
          delete handlersInElement[handler.id];
          element.removeEventListener(handler.type, handler.proxy, false);
      };
      if (!types) {
          handlersInElement.forEach(function (handler) { return removeEvent(handler); });
      }
      else {
          types.split(' ').forEach(function (type) {
              if (type) {
                  getHandlers(element, type, func, selector).forEach(function (handler) { return removeEvent(handler); });
              }
          });
      }
  }

  $.fn.trigger = function (type, extraParameters) {
      var event = parse(type);
      var eventObject;
      var eventParams = {
          bubbles: true,
          cancelable: true,
      };
      var isMouseEvent = ['click', 'mousedown', 'mouseup', 'mousemove'].indexOf(event.type) > -1;
      if (isMouseEvent) {
          // Note: MouseEvent 无法传入 detail 参数
          eventObject = new MouseEvent(event.type, eventParams);
      }
      else {
          eventParams.detail = extraParameters;
          eventObject = new CustomEvent(event.type, eventParams);
      }
      // @ts-ignore
      eventObject._detail = extraParameters;
      // @ts-ignore
      eventObject._ns = event.ns;
      return this.each(function () {
          this.dispatchEvent(eventObject);
      });
  };

  function extend(target, object1) {
      var objectN = [], len = arguments.length - 2;
      while ( len-- > 0 ) objectN[ len ] = arguments[ len + 2 ];

      objectN.unshift(object1);
      each(objectN, function (_, object) {
          each(object, function (prop, value) {
              if (!isUndefined(value)) {
                  target[prop] = value;
              }
          });
      });
      return target;
  }

  /**
   * 将数组或对象序列化，序列化后的字符串可作为 URL 查询字符串使用
   *
   * 若传入数组，则格式必须和 serializeArray 方法的返回值一样
   * @param obj 对象或数组
   * @example
  ```js
  param({ width: 1680, height: 1050 });
  // width=1680&height=1050
  ```
   * @example
  ```js
  param({ foo: { one: 1, two: 2 }})
  // foo[one]=1&foo[two]=2
  ```
   * @example
  ```js
  param({ids: [1, 2, 3]})
  // ids[]=1&ids[]=2&ids[]=3
  ```
   * @example
  ```js
  param([
    {"name":"name","value":"mdui"},
    {"name":"password","value":"123456"}
  ])
  // name=mdui&password=123456
  ```
   */
  function param(obj) {
      if (!isObjectLike(obj) && !Array.isArray(obj)) {
          return '';
      }
      var args = [];
      function destructure(key, value) {
          var keyTmp;
          if (isObjectLike(value)) {
              each(value, function (i, v) {
                  if (Array.isArray(value) && !isObjectLike(v)) {
                      keyTmp = '';
                  }
                  else {
                      keyTmp = i;
                  }
                  destructure((key + "[" + keyTmp + "]"), v);
              });
          }
          else {
              if (value == null || value === '') {
                  keyTmp = '=';
              }
              else {
                  keyTmp = "=" + (encodeURIComponent(value));
              }
              args.push(encodeURIComponent(key) + keyTmp);
          }
      }
      if (Array.isArray(obj)) {
          each(obj, function () {
              destructure(this.name, this.value);
          });
      }
      else {
          each(obj, destructure);
      }
      return args.join('&');
  }

  // 全局配置参数
  var globalOptions = {};
  // 全局事件名
  var ajaxEvents = {
      ajaxStart: 'start.mdui.ajax',
      ajaxSuccess: 'success.mdui.ajax',
      ajaxError: 'error.mdui.ajax',
      ajaxComplete: 'complete.mdui.ajax',
  };

  /**
   * 判断此请求方法是否通过查询字符串提交参数
   * @param method 请求方法，大写
   */
  function isQueryStringData(method) {
      return ['GET', 'HEAD'].indexOf(method) >= 0;
  }
  /**
   * 添加参数到 URL 上，且 URL 中不存在 ? 时，自动把第一个 & 替换为 ?
   * @param url
   * @param query
   */
  function appendQuery(url, query) {
      return (url + "&" + query).replace(/[&?]{1,2}/, '?');
  }
  /**
   * 合并请求参数，参数优先级：options > globalOptions > defaults
   * @param options
   */
  function mergeOptions(options) {
      // 默认参数
      var defaults = {
          url: '',
          method: 'GET',
          data: '',
          processData: true,
          async: true,
          cache: true,
          username: '',
          password: '',
          headers: {},
          xhrFields: {},
          statusCode: {},
          dataType: 'text',
          contentType: 'application/x-www-form-urlencoded',
          timeout: 0,
          global: true,
      };
      // globalOptions 中的回调函数不合并
      each(globalOptions, function (key, value) {
          var callbacks = [
              'beforeSend',
              'success',
              'error',
              'complete',
              'statusCode' ];
          // @ts-ignore
          if (callbacks.indexOf(key) < 0 && !isUndefined(value)) {
              defaults[key] = value;
          }
      });
      return extend({}, defaults, options);
  }
  /**
   * 发送 ajax 请求
   * @param options
   * @example
  ```js
  ajax({
    method: "POST",
    url: "some.php",
    data: { name: "John", location: "Boston" }
  }).then(function( msg ) {
    alert( "Data Saved: " + msg );
  });
  ```
   */
  function ajax(options) {
      // 是否已取消请求
      var isCanceled = false;
      // 事件参数
      var eventParams = {};
      // 参数合并
      var mergedOptions = mergeOptions(options);
      var url = mergedOptions.url || window.location.toString();
      var method = mergedOptions.method.toUpperCase();
      var data = mergedOptions.data;
      var processData = mergedOptions.processData;
      var async = mergedOptions.async;
      var cache = mergedOptions.cache;
      var username = mergedOptions.username;
      var password = mergedOptions.password;
      var headers = mergedOptions.headers;
      var xhrFields = mergedOptions.xhrFields;
      var statusCode = mergedOptions.statusCode;
      var dataType = mergedOptions.dataType;
      var contentType = mergedOptions.contentType;
      var timeout = mergedOptions.timeout;
      var global = mergedOptions.global;
      // 需要发送的数据
      // GET/HEAD 请求和 processData 为 true 时，转换为查询字符串格式，特殊格式不转换
      if (data &&
          (isQueryStringData(method) || processData) &&
          !isString(data) &&
          !(data instanceof ArrayBuffer) &&
          !(data instanceof Blob) &&
          !(data instanceof Document) &&
          !(data instanceof FormData)) {
          data = param(data);
      }
      // 对于 GET、HEAD 类型的请求，把 data 数据添加到 URL 中
      if (data && isQueryStringData(method)) {
          // 查询字符串拼接到 URL 中
          url = appendQuery(url, data);
          data = null;
      }
      /**
       * 触发事件和回调函数
       * @param event
       * @param params
       * @param callback
       * @param args
       */
      function trigger(event, params, callback) {
          var args = [], len = arguments.length - 3;
          while ( len-- > 0 ) args[ len ] = arguments[ len + 3 ];

          // 触发全局事件
          if (global) {
              $(document).trigger(event, params);
          }
          // 触发 ajax 回调和事件
          var result1;
          var result2;
          if (callback) {
              // 全局回调
              if (callback in globalOptions) {
                  // @ts-ignore
                  result1 = globalOptions[callback].apply(globalOptions, args);
              }
              // 自定义回调
              if (mergedOptions[callback]) {
                  // @ts-ignore
                  result2 = mergedOptions[callback].apply(mergedOptions, args);
              }
              // beforeSend 回调返回 false 时取消 ajax 请求
              if (callback === 'beforeSend' &&
                  (result1 === false || result2 === false)) {
                  isCanceled = true;
              }
          }
      }
      // XMLHttpRequest 请求
      function XHR() {
          var textStatus;
          return new Promise(function (resolve, reject) {
              // GET/HEAD 请求的缓存处理
              if (isQueryStringData(method) && !cache) {
                  url = appendQuery(url, ("_=" + (Date.now())));
              }
              // 创建 XHR
              var xhr = new XMLHttpRequest();
              xhr.open(method, url, async, username, password);
              if (contentType ||
                  (data && !isQueryStringData(method) && contentType !== false)) {
                  xhr.setRequestHeader('Content-Type', contentType);
              }
              // 设置 Accept
              if (dataType === 'json') {
                  xhr.setRequestHeader('Accept', 'application/json, text/javascript');
              }
              // 添加 headers
              if (headers) {
                  each(headers, function (key, value) {
                      // undefined 值不发送，string 和 null 需要发送
                      if (!isUndefined(value)) {
                          xhr.setRequestHeader(key, value + ''); // 把 null 转换成字符串
                      }
                  });
              }
              // 检查是否是跨域请求，跨域请求时不添加 X-Requested-With
              var crossDomain = /^([\w-]+:)?\/\/([^/]+)/.test(url) &&
                  RegExp.$2 !== window.location.host;
              if (!crossDomain) {
                  xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
              }
              if (xhrFields) {
                  each(xhrFields, function (key, value) {
                      // @ts-ignore
                      xhr[key] = value;
                  });
              }
              eventParams.xhr = xhr;
              eventParams.options = mergedOptions;
              var xhrTimeout;
              xhr.onload = function () {
                  if (xhrTimeout) {
                      clearTimeout(xhrTimeout);
                  }
                  // AJAX 返回的 HTTP 响应码是否表示成功
                  var isHttpStatusSuccess = (xhr.status >= 200 && xhr.status < 300) ||
                      xhr.status === 304 ||
                      xhr.status === 0;
                  var responseData;
                  if (isHttpStatusSuccess) {
                      if (xhr.status === 204 || method === 'HEAD') {
                          textStatus = 'nocontent';
                      }
                      else if (xhr.status === 304) {
                          textStatus = 'notmodified';
                      }
                      else {
                          textStatus = 'success';
                      }
                      if (dataType === 'json') {
                          try {
                              responseData =
                                  method === 'HEAD' ? undefined : JSON.parse(xhr.responseText);
                              eventParams.data = responseData;
                          }
                          catch (err) {
                              textStatus = 'parsererror';
                              trigger(ajaxEvents.ajaxError, eventParams, 'error', xhr, textStatus);
                              reject(new Error(textStatus));
                          }
                          if (textStatus !== 'parsererror') {
                              trigger(ajaxEvents.ajaxSuccess, eventParams, 'success', responseData, textStatus, xhr);
                              resolve(responseData);
                          }
                      }
                      else {
                          responseData =
                              method === 'HEAD'
                                  ? undefined
                                  : xhr.responseType === 'text' || xhr.responseType === ''
                                      ? xhr.responseText
                                      : xhr.response;
                          eventParams.data = responseData;
                          trigger(ajaxEvents.ajaxSuccess, eventParams, 'success', responseData, textStatus, xhr);
                          resolve(responseData);
                      }
                  }
                  else {
                      textStatus = 'error';
                      trigger(ajaxEvents.ajaxError, eventParams, 'error', xhr, textStatus);
                      reject(new Error(textStatus));
                  }
                  // statusCode
                  each([globalOptions.statusCode, statusCode], function (_, func) {
                      if (func && func[xhr.status]) {
                          if (isHttpStatusSuccess) {
                              func[xhr.status](responseData, textStatus, xhr);
                          }
                          else {
                              func[xhr.status](xhr, textStatus);
                          }
                      }
                  });
                  trigger(ajaxEvents.ajaxComplete, eventParams, 'complete', xhr, textStatus);
              };
              xhr.onerror = function () {
                  if (xhrTimeout) {
                      clearTimeout(xhrTimeout);
                  }
                  trigger(ajaxEvents.ajaxError, eventParams, 'error', xhr, xhr.statusText);
                  trigger(ajaxEvents.ajaxComplete, eventParams, 'complete', xhr, 'error');
                  reject(new Error(xhr.statusText));
              };
              xhr.onabort = function () {
                  var statusText = 'abort';
                  if (xhrTimeout) {
                      statusText = 'timeout';
                      clearTimeout(xhrTimeout);
                  }
                  trigger(ajaxEvents.ajaxError, eventParams, 'error', xhr, statusText);
                  trigger(ajaxEvents.ajaxComplete, eventParams, 'complete', xhr, statusText);
                  reject(new Error(statusText));
              };
              // ajax start 回调
              trigger(ajaxEvents.ajaxStart, eventParams, 'beforeSend', xhr);
              if (isCanceled) {
                  reject(new Error('cancel'));
                  return;
              }
              // Timeout
              if (timeout > 0) {
                  xhrTimeout = setTimeout(function () {
                      xhr.abort();
                  }, timeout);
              }
              // 发送 XHR
              xhr.send(data);
          });
      }
      return XHR();
  }

  $.ajax = ajax;

  /**
   * 为 Ajax 请求设置全局配置参数
   * @param options 键值对参数
   * @example
  ```js
  ajaxSetup({
    dataType: 'json',
    method: 'POST',
  });
  ```
   */
  function ajaxSetup(options) {
      return extend(globalOptions, options);
  }

  $.ajaxSetup = ajaxSetup;

  $.contains = contains;

  var dataNS = '_mduiElementDataStorage';

  /**
   * 在元素上设置键值对数据
   * @param element
   * @param object
   */
  function setObjectToElement(element, object) {
      // @ts-ignore
      if (!element[dataNS]) {
          // @ts-ignore
          element[dataNS] = {};
      }
      each(object, function (key, value) {
          // @ts-ignore
          element[dataNS][toCamelCase(key)] = value;
      });
  }
  function data(element, key, value) {
      var obj;

      // 根据键值对设置值
      // data(element, { 'key' : 'value' })
      if (isObjectLike(key)) {
          setObjectToElement(element, key);
          return key;
      }
      // 根据 key、value 设置值
      // data(element, 'key', 'value')
      if (!isUndefined(value)) {
          setObjectToElement(element, ( obj = {}, obj[key] = value, obj ));
          return value;
      }
      // 获取所有值
      // data(element)
      if (isUndefined(key)) {
          // @ts-ignore
          return element[dataNS] ? element[dataNS] : {};
      }
      // 从 dataNS 中获取指定值
      // data(element, 'key')
      key = toCamelCase(key);
      // @ts-ignore
      if (element[dataNS] && key in element[dataNS]) {
          // @ts-ignore
          return element[dataNS][key];
      }
      return undefined;
  }

  $.data = data;

  $.each = each;

  $.extend = function () {
      var this$1 = this;
      var objectN = [], len = arguments.length;
      while ( len-- ) objectN[ len ] = arguments[ len ];

      if (objectN.length === 1) {
          each(objectN[0], function (prop, value) {
              this$1[prop] = value;
          });
          return this;
      }
      return extend.apply(void 0, [ objectN.shift(), objectN.shift() ].concat( objectN ));
  };

  function map(elements, callback) {
      var ref;

      var value;
      var ret = [];
      each(elements, function (i, element) {
          value = callback.call(window, element, i);
          if (value != null) {
              ret.push(value);
          }
      });
      return (ref = []).concat.apply(ref, ret);
  }

  $.map = map;

  $.merge = merge;

  $.param = param;

  /**
   * 移除指定元素上存放的数据
   * @param element 存放数据的元素
   * @param name
   * 数据键名
   *
   * 若未指定键名，将移除元素上所有数据
   *
   * 多个键名可以用空格分隔，或者用数组表示多个键名
    @example
  ```js
  // 移除元素上键名为 name 的数据
  removeData(document.body, 'name');
  ```
   * @example
  ```js
  // 移除元素上键名为 name1 和 name2 的数据
  removeData(document.body, 'name1 name2');
  ```
   * @example
  ```js
  // 移除元素上键名为 name1 和 name2 的数据
  removeData(document.body, ['name1', 'name2']);
  ```
   * @example
  ```js
  // 移除元素上所有数据
  removeData(document.body);
  ```
   */
  function removeData(element, name) {
      // @ts-ignore
      if (!element[dataNS]) {
          return;
      }
      var remove = function (nameItem) {
          nameItem = toCamelCase(nameItem);
          // @ts-ignore
          if (element[dataNS][nameItem]) {
              // @ts-ignore
              element[dataNS][nameItem] = null;
              // @ts-ignore
              delete element[dataNS][nameItem];
          }
      };
      if (isUndefined(name)) {
          // @ts-ignore
          element[dataNS] = null;
          // @ts-ignore
          delete element[dataNS];
          // @ts-ignore
      }
      else if (isString(name)) {
          name
              .split(' ')
              .filter(function (nameItem) { return nameItem; })
              .forEach(function (nameItem) { return remove(nameItem); });
      }
      else {
          each(name, function (_, nameItem) { return remove(nameItem); });
      }
  }

  $.removeData = removeData;

  /**
   * 过滤掉数组中的重复元素
   * @param arr 数组
   * @example
  ```js
  unique([1, 2, 12, 3, 2, 1, 2, 1, 1]);
  // [1, 2, 12, 3]
  ```
   */
  function unique(arr) {
      var result = [];
      each(arr, function (_, val) {
          if (result.indexOf(val) === -1) {
              result.push(val);
          }
      });
      return result;
  }

  $.unique = unique;

  $.fn.add = function (selector) {
      return new JQ(unique(merge(this.get(), $(selector).get())));
  };

  each(['add', 'remove', 'toggle'], function (_, name) {
      $.fn[(name + "Class")] = function (className) {
          if (name === 'remove' && !arguments.length) {
              return this.each(function (_, element) {
                  element.setAttribute('class', '');
              });
          }
          return this.each(function (i, element) {
              if (!isElement(element)) {
                  return;
              }
              var classes = (isFunction(className)
                  ? className.call(element, i, element.getAttribute('class') || '')
                  : className)
                  .split(' ')
                  .filter(function (name) { return name; });
              each(classes, function (_, cls) {
                  element.classList[name](cls);
              });
          });
      };
  });

  each(['insertBefore', 'insertAfter'], function (nameIndex, name) {
      $.fn[name] = function (target) {
          var $element = nameIndex ? $(this.get().reverse()) : this; // 顺序和 jQuery 保持一致
          var $target = $(target);
          var result = [];
          $target.each(function (index, target) {
              if (!target.parentNode) {
                  return;
              }
              $element.each(function (_, element) {
                  var newItem = index
                      ? element.cloneNode(true)
                      : element;
                  var existingItem = nameIndex ? target.nextSibling : target;
                  result.push(newItem);
                  target.parentNode.insertBefore(newItem, existingItem);
              });
          });
          return $(nameIndex ? result.reverse() : result);
      };
  });

  /**
   * 是否不是 HTML 字符串（包裹在 <> 中）
   * @param target
   */
  function isPlainText(target) {
      return (isString(target) && (target[0] !== '<' || target[target.length - 1] !== '>'));
  }
  each(['before', 'after'], function (nameIndex, name) {
      $.fn[name] = function () {
          var args = [], len = arguments.length;
          while ( len-- ) args[ len ] = arguments[ len ];

          // after 方法，多个参数需要按参数顺序添加到元素后面，所以需要将参数顺序反向处理
          if (nameIndex === 1) {
              args = args.reverse();
          }
          return this.each(function (index, element) {
              var targets = isFunction(args[0])
                  ? [args[0].call(element, index, element.innerHTML)]
                  : args;
              each(targets, function (_, target) {
                  var $target;
                  if (isPlainText(target)) {
                      $target = $(getChildNodesArray(target, 'div'));
                  }
                  else if (index && isElement(target)) {
                      $target = $(target.cloneNode(true));
                  }
                  else {
                      $target = $(target);
                  }
                  $target[nameIndex ? 'insertAfter' : 'insertBefore'](element);
              });
          });
      };
  });

  $.fn.off = function (types, selector, callback) {
      var this$1 = this;

      // types 是对象
      if (isObjectLike(types)) {
          each(types, function (type, fn) {
              // this.off('click', undefined, function () {})
              // this.off('click', '.box', function () {})
              this$1.off(type, selector, fn);
          });
          return this;
      }
      // selector 不存在
      if (selector === false || isFunction(selector)) {
          callback = selector;
          selector = undefined;
          // this.off('click', undefined, function () {})
      }
      // callback 传入 `false`，相当于 `return false`
      if (callback === false) {
          callback = returnFalse;
      }
      return this.each(function () {
          remove(this, types, callback, selector);
      });
  };

  $.fn.on = function (types, selector, data, callback, one) {
      var this$1 = this;

      // types 可以是 type/func 对象
      if (isObjectLike(types)) {
          // (types-Object, selector, data)
          if (!isString(selector)) {
              // (types-Object, data)
              data = data || selector;
              selector = undefined;
          }
          each(types, function (type, fn) {
              // selector 和 data 都可能是 undefined
              // @ts-ignore
              this$1.on(type, selector, data, fn, one);
          });
          return this;
      }
      if (data == null && callback == null) {
          // (types, fn)
          callback = selector;
          data = selector = undefined;
      }
      else if (callback == null) {
          if (isString(selector)) {
              // (types, selector, fn)
              callback = data;
              data = undefined;
          }
          else {
              // (types, data, fn)
              callback = data;
              data = selector;
              selector = undefined;
          }
      }
      if (callback === false) {
          callback = returnFalse;
      }
      else if (!callback) {
          return this;
      }
      // $().one()
      if (one) {
          // eslint-disable-next-line @typescript-eslint/no-this-alias
          var _this = this;
          var origCallback = callback;
          callback = function (event) {
              _this.off(event.type, selector, callback);
              // eslint-disable-next-line prefer-rest-params
              return origCallback.apply(this, arguments);
          };
      }
      return this.each(function () {
          add(this, types, callback, data, selector);
      });
  };

  each(ajaxEvents, function (name, eventName) {
      $.fn[name] = function (fn) {
          return this.on(eventName, function (e, params) {
              fn(e, params.xhr, params.options, params.data);
          });
      };
  });

  $.fn.map = function (callback) {
      return new JQ(map(this, function (element, i) { return callback.call(element, i, element); }));
  };

  $.fn.clone = function () {
      return this.map(function () {
          return this.cloneNode(true);
      });
  };

  $.fn.is = function (selector) {
      var isMatched = false;
      if (isFunction(selector)) {
          this.each(function (index, element) {
              if (selector.call(element, index, element)) {
                  isMatched = true;
              }
          });
          return isMatched;
      }
      if (isString(selector)) {
          this.each(function (_, element) {
              if (isDocument(element) || isWindow(element)) {
                  return;
              }
              // @ts-ignore
              var matches = element.matches || element.msMatchesSelector;
              if (matches.call(element, selector)) {
                  isMatched = true;
              }
          });
          return isMatched;
      }
      var $compareWith = $(selector);
      this.each(function (_, element) {
          $compareWith.each(function (_, compare) {
              if (element === compare) {
                  isMatched = true;
              }
          });
      });
      return isMatched;
  };

  $.fn.remove = function (selector) {
      return this.each(function (_, element) {
          if (element.parentNode && (!selector || $(element).is(selector))) {
              element.parentNode.removeChild(element);
          }
      });
  };

  each(['prepend', 'append'], function (nameIndex, name) {
      $.fn[name] = function () {
          var args = [], len = arguments.length;
          while ( len-- ) args[ len ] = arguments[ len ];

          return this.each(function (index, element) {
              var ref;

              var childNodes = element.childNodes;
              var childLength = childNodes.length;
              var child = childLength
                  ? childNodes[nameIndex ? childLength - 1 : 0]
                  : document.createElement('div');
              if (!childLength) {
                  element.appendChild(child);
              }
              var contents = isFunction(args[0])
                  ? [args[0].call(element, index, element.innerHTML)]
                  : args;
              // 如果不是字符串，则仅第一个元素使用原始元素，其他的都克隆自第一个元素
              if (index) {
                  contents = contents.map(function (content) {
                      return isString(content) ? content : $(content).clone();
                  });
              }
              (ref = $(child))[nameIndex ? 'after' : 'before'].apply(ref, contents);
              if (!childLength) {
                  element.removeChild(child);
              }
          });
      };
  });

  each(['appendTo', 'prependTo'], function (nameIndex, name) {
      $.fn[name] = function (target) {
          var extraChilds = [];
          var $target = $(target).map(function (_, element) {
              var childNodes = element.childNodes;
              var childLength = childNodes.length;
              if (childLength) {
                  return childNodes[nameIndex ? 0 : childLength - 1];
              }
              var child = document.createElement('div');
              element.appendChild(child);
              extraChilds.push(child);
              return child;
          });
          var $result = this[nameIndex ? 'insertBefore' : 'insertAfter']($target);
          $(extraChilds).remove();
          return $result;
      };
  });

  each(['attr', 'prop', 'css'], function (nameIndex, name) {
      function set(element, key, value) {
          // 值为 undefined 时，不修改
          if (isUndefined(value)) {
              return;
          }
          switch (nameIndex) {
              // attr
              case 0:
                  if (isNull(value)) {
                      element.removeAttribute(key);
                  }
                  else {
                      element.setAttribute(key, value);
                  }
                  break;
              // prop
              case 1:
                  // @ts-ignore
                  element[key] = value;
                  break;
              // css
              default:
                  key = toCamelCase(key);
                  // @ts-ignore
                  element.style[key] = isNumber(value)
                      ? ("" + value + (cssNumber.indexOf(key) > -1 ? '' : 'px'))
                      : value;
                  break;
          }
      }
      function get(element, key) {
          switch (nameIndex) {
              // attr
              case 0:
                  // 属性不存在时，原生 getAttribute 方法返回 null，而 jquery 返回 undefined。这里和 jquery 保持一致
                  var value = element.getAttribute(key);
                  return isNull(value) ? undefined : value;
              // prop
              case 1:
                  // @ts-ignore
                  return element[key];
              // css
              default:
                  return getStyle(element, key);
          }
      }
      $.fn[name] = function (key, value) {
          var this$1 = this;

          if (isObjectLike(key)) {
              each(key, function (k, v) {
                  // @ts-ignore
                  this$1[name](k, v);
              });
              return this;
          }
          if (arguments.length === 1) {
              var element = this[0];
              return isElement(element) ? get(element, key) : undefined;
          }
          return this.each(function (i, element) {
              set(element, key, isFunction(value) ? value.call(element, i, get(element, key)) : value);
          });
      };
  });

  $.fn.children = function (selector) {
      var children = [];
      this.each(function (_, element) {
          each(element.childNodes, function (__, childNode) {
              if (!isElement(childNode)) {
                  return;
              }
              if (!selector || $(childNode).is(selector)) {
                  children.push(childNode);
              }
          });
      });
      return new JQ(unique(children));
  };

  $.fn.slice = function () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];

      return new JQ([].slice.apply(this, args));
  };

  $.fn.eq = function (index) {
      var ret = index === -1 ? this.slice(index) : this.slice(index, +index + 1);
      return new JQ(ret);
  };

  function dir($elements, nameIndex, node, selector, filter) {
      var ret = [];
      var target;
      $elements.each(function (_, element) {
          target = element[node];
          // 不能包含最顶层的 document 元素
          while (target && isElement(target)) {
              // prevUntil, nextUntil, parentsUntil
              if (nameIndex === 2) {
                  if (selector && $(target).is(selector)) {
                      break;
                  }
                  if (!filter || $(target).is(filter)) {
                      ret.push(target);
                  }
              }
              // prev, next, parent
              else if (nameIndex === 0) {
                  if (!selector || $(target).is(selector)) {
                      ret.push(target);
                  }
                  break;
              }
              // prevAll, nextAll, parents
              else {
                  if (!selector || $(target).is(selector)) {
                      ret.push(target);
                  }
              }
              // @ts-ignore
              target = target[node];
          }
      });
      return new JQ(unique(ret));
  }

  each(['', 's', 'sUntil'], function (nameIndex, name) {
      $.fn[("parent" + name)] = function (selector, filter) {
          // parents、parentsUntil 需要把元素的顺序反向处理，以便和 jQuery 的结果一致
          var $nodes = !nameIndex ? this : $(this.get().reverse());
          return dir($nodes, nameIndex, 'parentNode', selector, filter);
      };
  });

  $.fn.closest = function (selector) {
      if (this.is(selector)) {
          return this;
      }
      var matched = [];
      this.parents().each(function (_, element) {
          if ($(element).is(selector)) {
              matched.push(element);
              return false;
          }
      });
      return new JQ(matched);
  };

  var rbrace = /^(?:{[\w\W]*\}|\[[\w\W]*\])$/;
  // 从 `data-*` 中获取的值，需要经过该函数转换
  function getData(value) {
      if (value === 'true') {
          return true;
      }
      if (value === 'false') {
          return false;
      }
      if (value === 'null') {
          return null;
      }
      if (value === +value + '') {
          return +value;
      }
      if (rbrace.test(value)) {
          return JSON.parse(value);
      }
      return value;
  }
  // 若 value 不存在，则从 `data-*` 中获取值
  function dataAttr(element, key, value) {
      if (isUndefined(value) && element.nodeType === 1) {
          var name = 'data-' + toKebabCase(key);
          value = element.getAttribute(name);
          if (isString(value)) {
              try {
                  value = getData(value);
              }
              catch (e) { }
          }
          else {
              value = undefined;
          }
      }
      return value;
  }
  $.fn.data = function (key, value) {
      // 获取所有值
      if (isUndefined(key)) {
          if (!this.length) {
              return undefined;
          }
          var element = this[0];
          var resultData = data(element);
          // window, document 上不存在 `data-*` 属性
          if (element.nodeType !== 1) {
              return resultData;
          }
          // 从 `data-*` 中获取值
          var attrs = element.attributes;
          var i = attrs.length;
          while (i--) {
              if (attrs[i]) {
                  var name = attrs[i].name;
                  if (name.indexOf('data-') === 0) {
                      name = toCamelCase(name.slice(5));
                      resultData[name] = dataAttr(element, name, resultData[name]);
                  }
              }
          }
          return resultData;
      }
      // 同时设置多个值
      if (isObjectLike(key)) {
          return this.each(function () {
              data(this, key);
          });
      }
      // value 传入了 undefined
      if (arguments.length === 2 && isUndefined(value)) {
          return this;
      }
      // 设置值
      if (!isUndefined(value)) {
          return this.each(function () {
              data(this, key, value);
          });
      }
      // 获取值
      if (!this.length) {
          return undefined;
      }
      return dataAttr(this[0], key, data(this[0], key));
  };

  $.fn.empty = function () {
      return this.each(function () {
          this.innerHTML = '';
      });
  };

  $.fn.extend = function (obj) {
      each(obj, function (prop, value) {
          // 在 JQ 对象上扩展方法时，需要自己添加 typescript 的类型定义
          $.fn[prop] = value;
      });
      return this;
  };

  $.fn.filter = function (selector) {
      if (isFunction(selector)) {
          return this.map(function (index, element) { return selector.call(element, index, element) ? element : undefined; });
      }
      if (isString(selector)) {
          return this.map(function (_, element) { return $(element).is(selector) ? element : undefined; });
      }
      var $selector = $(selector);
      return this.map(function (_, element) { return $selector.get().indexOf(element) > -1 ? element : undefined; });
  };

  $.fn.first = function () {
      return this.eq(0);
  };

  $.fn.has = function (selector) {
      var $targets = isString(selector) ? this.find(selector) : $(selector);
      var length = $targets.length;
      return this.map(function () {
          for (var i = 0; i < length; i += 1) {
              if (contains(this, $targets[i])) {
                  return this;
              }
          }
          return;
      });
  };

  $.fn.hasClass = function (className) {
      return this[0].classList.contains(className);
  };

  /**
   * 值上面的 padding、border、margin 处理
   * @param element
   * @param name
   * @param value
   * @param funcIndex
   * @param includeMargin
   * @param multiply
   */
  function handleExtraWidth(element, name, value, funcIndex, includeMargin, multiply) {
      // 获取元素的 padding, border, margin 宽度（两侧宽度的和）
      var getExtraWidthValue = function (extra) {
          return (getExtraWidth(element, name.toLowerCase(), extra) *
              multiply);
      };
      if (funcIndex === 2 && includeMargin) {
          value += getExtraWidthValue('margin');
      }
      if (isBorderBox(element)) {
          // IE 为 box-sizing: border-box 时，得到的值不含 border 和 padding，这里先修复
          // 仅获取时需要处理，multiply === 1 为 get
          if (isIE() && multiply === 1) {
              value += getExtraWidthValue('border');
              value += getExtraWidthValue('padding');
          }
          if (funcIndex === 0) {
              value -= getExtraWidthValue('border');
          }
          if (funcIndex === 1) {
              value -= getExtraWidthValue('border');
              value -= getExtraWidthValue('padding');
          }
      }
      else {
          if (funcIndex === 0) {
              value += getExtraWidthValue('padding');
          }
          if (funcIndex === 2) {
              value += getExtraWidthValue('border');
              value += getExtraWidthValue('padding');
          }
      }
      return value;
  }
  /**
   * 获取元素的样式值
   * @param element
   * @param name
   * @param funcIndex 0: innerWidth, innerHeight; 1: width, height; 2: outerWidth, outerHeight
   * @param includeMargin
   */
  function get(element, name, funcIndex, includeMargin) {
      var clientProp = "client" + name;
      var scrollProp = "scroll" + name;
      var offsetProp = "offset" + name;
      var innerProp = "inner" + name;
      // $(window).width()
      if (isWindow(element)) {
          // outerWidth, outerHeight 需要包含滚动条的宽度
          return funcIndex === 2
              ? element[innerProp]
              : toElement(document)[clientProp];
      }
      // $(document).width()
      if (isDocument(element)) {
          var doc = toElement(element);
          return Math.max(
          // @ts-ignore
          element.body[scrollProp], doc[scrollProp], 
          // @ts-ignore
          element.body[offsetProp], doc[offsetProp], doc[clientProp]);
      }
      var value = parseFloat(getComputedStyleValue(element, name.toLowerCase()) || '0');
      return handleExtraWidth(element, name, value, funcIndex, includeMargin, 1);
  }
  /**
   * 设置元素的样式值
   * @param element
   * @param elementIndex
   * @param name
   * @param funcIndex 0: innerWidth, innerHeight; 1: width, height; 2: outerWidth, outerHeight
   * @param includeMargin
   * @param value
   */
  function set(element, elementIndex, name, funcIndex, includeMargin, value) {
      var computedValue = isFunction(value)
          ? value.call(element, elementIndex, get(element, name, funcIndex, includeMargin))
          : value;
      if (computedValue == null) {
          return;
      }
      var $element = $(element);
      var dimension = name.toLowerCase();
      // 特殊的值，不需要计算 padding、border、margin
      if (['auto', 'inherit', ''].indexOf(computedValue) > -1) {
          $element.css(dimension, computedValue);
          return;
      }
      // 其他值保留原始单位。注意：如果不使用 px 作为单位，则算出的值一般是不准确的
      var suffix = computedValue.toString().replace(/\b[0-9.]*/, '');
      var numerical = parseFloat(computedValue);
      computedValue =
          handleExtraWidth(element, name, numerical, funcIndex, includeMargin, -1) +
              (suffix || 'px');
      $element.css(dimension, computedValue);
  }
  each(['Width', 'Height'], function (_, name) {
      each([("inner" + name), name.toLowerCase(), ("outer" + name)], function (funcIndex, funcName) {
          $.fn[funcName] = function (margin, value) {
              // 是否是赋值操作
              var isSet = arguments.length && (funcIndex < 2 || !isBoolean(margin));
              var includeMargin = margin === true || value === true;
              // 获取第一个元素的值
              if (!isSet) {
                  return this.length
                      ? get(this[0], name, funcIndex, includeMargin)
                      : undefined;
              }
              // 设置每个元素的值
              return this.each(function (index, element) { return set(element, index, name, funcIndex, includeMargin, margin); });
          };
      });
  });

  $.fn.hide = function () {
      return this.each(function () {
          this.style.display = 'none';
      });
  };

  each(['val', 'html', 'text'], function (nameIndex, name) {
      var props = {
          0: 'value',
          1: 'innerHTML',
          2: 'textContent',
      };
      var propName = props[nameIndex];
      function get($elements) {
          // text() 获取所有元素的文本
          if (nameIndex === 2) {
              // @ts-ignore
              return map($elements, function (element) { return toElement(element)[propName]; }).join('');
          }
          // 空集合时，val() 和 html() 返回 undefined
          if (!$elements.length) {
              return undefined;
          }
          // val() 和 html() 仅获取第一个元素的内容
          var firstElement = $elements[0];
          // select multiple 返回数组
          if (nameIndex === 0 && $(firstElement).is('select[multiple]')) {
              return map($(firstElement).find('option:checked'), function (element) { return element.value; });
          }
          // @ts-ignore
          return firstElement[propName];
      }
      function set(element, value) {
          // text() 和 html() 赋值为 undefined，则保持原内容不变
          // val() 赋值为 undefined 则赋值为空
          if (isUndefined(value)) {
              if (nameIndex !== 0) {
                  return;
              }
              value = '';
          }
          if (nameIndex === 1 && isElement(value)) {
              value = value.outerHTML;
          }
          // @ts-ignore
          element[propName] = value;
      }
      $.fn[name] = function (value) {
          // 获取值
          if (!arguments.length) {
              return get(this);
          }
          // 设置值
          return this.each(function (i, element) {
              var computedValue = isFunction(value)
                  ? value.call(element, i, get($(element)))
                  : value;
              // value 是数组，则选中数组中的元素，反选不在数组中的元素
              if (nameIndex === 0 && Array.isArray(computedValue)) {
                  // select[multiple]
                  if ($(element).is('select[multiple]')) {
                      map($(element).find('option'), function (option) { return (option.selected =
                          computedValue.indexOf(option.value) >
                              -1); });
                  }
                  // 其他 checkbox, radio 等元素
                  else {
                      element.checked =
                          computedValue.indexOf(element.value) > -1;
                  }
              }
              else {
                  set(element, computedValue);
              }
          });
      };
  });

  $.fn.index = function (selector) {
      if (!arguments.length) {
          return this.eq(0).parent().children().get().indexOf(this[0]);
      }
      if (isString(selector)) {
          return $(selector).get().indexOf(this[0]);
      }
      return this.get().indexOf($(selector)[0]);
  };

  $.fn.last = function () {
      return this.eq(-1);
  };

  each(['', 'All', 'Until'], function (nameIndex, name) {
      $.fn[("next" + name)] = function (selector, filter) {
          return dir(this, nameIndex, 'nextElementSibling', selector, filter);
      };
  });

  $.fn.not = function (selector) {
      var $excludes = this.filter(selector);
      return this.map(function (_, element) { return $excludes.index(element) > -1 ? undefined : element; });
  };

  /**
   * 返回最近的用于定位的父元素
   */
  $.fn.offsetParent = function () {
      return this.map(function () {
          var offsetParent = this.offsetParent;
          while (offsetParent && $(offsetParent).css('position') === 'static') {
              offsetParent = offsetParent.offsetParent;
          }
          return offsetParent || document.documentElement;
      });
  };

  function floatStyle($element, name) {
      return parseFloat($element.css(name));
  }
  $.fn.position = function () {
      if (!this.length) {
          return undefined;
      }
      var $element = this.eq(0);
      var currentOffset;
      var parentOffset = {
          left: 0,
          top: 0,
      };
      if ($element.css('position') === 'fixed') {
          currentOffset = $element[0].getBoundingClientRect();
      }
      else {
          currentOffset = $element.offset();
          var $offsetParent = $element.offsetParent();
          parentOffset = $offsetParent.offset();
          parentOffset.top += floatStyle($offsetParent, 'border-top-width');
          parentOffset.left += floatStyle($offsetParent, 'border-left-width');
      }
      return {
          top: currentOffset.top - parentOffset.top - floatStyle($element, 'margin-top'),
          left: currentOffset.left -
              parentOffset.left -
              floatStyle($element, 'margin-left'),
      };
  };

  function get$1(element) {
      if (!element.getClientRects().length) {
          return { top: 0, left: 0 };
      }
      var rect = element.getBoundingClientRect();
      var win = element.ownerDocument.defaultView;
      return {
          top: rect.top + win.pageYOffset,
          left: rect.left + win.pageXOffset,
      };
  }
  function set$1(element, value, index) {
      var $element = $(element);
      var position = $element.css('position');
      if (position === 'static') {
          $element.css('position', 'relative');
      }
      var currentOffset = get$1(element);
      var currentTopString = $element.css('top');
      var currentLeftString = $element.css('left');
      var currentTop;
      var currentLeft;
      var calculatePosition = (position === 'absolute' || position === 'fixed') &&
          (currentTopString + currentLeftString).indexOf('auto') > -1;
      if (calculatePosition) {
          var currentPosition = $element.position();
          currentTop = currentPosition.top;
          currentLeft = currentPosition.left;
      }
      else {
          currentTop = parseFloat(currentTopString);
          currentLeft = parseFloat(currentLeftString);
      }
      var computedValue = isFunction(value)
          ? value.call(element, index, extend({}, currentOffset))
          : value;
      $element.css({
          top: computedValue.top != null
              ? computedValue.top - currentOffset.top + currentTop
              : undefined,
          left: computedValue.left != null
              ? computedValue.left - currentOffset.left + currentLeft
              : undefined,
      });
  }
  $.fn.offset = function (value) {
      // 获取坐标
      if (!arguments.length) {
          if (!this.length) {
              return undefined;
          }
          return get$1(this[0]);
      }
      // 设置坐标
      return this.each(function (index) {
          set$1(this, value, index);
      });
  };

  $.fn.one = function (types, selector, data, callback) {
      // @ts-ignore
      return this.on(types, selector, data, callback, true);
  };

  each(['', 'All', 'Until'], function (nameIndex, name) {
      $.fn[("prev" + name)] = function (selector, filter) {
          // prevAll、prevUntil 需要把元素的顺序倒序处理，以便和 jQuery 的结果一致
          var $nodes = !nameIndex ? this : $(this.get().reverse());
          return dir($nodes, nameIndex, 'previousElementSibling', selector, filter);
      };
  });

  $.fn.removeAttr = function (attributeName) {
      var names = attributeName.split(' ').filter(function (name) { return name; });
      return this.each(function () {
          var this$1 = this;

          each(names, function (_, name) {
              this$1.removeAttribute(name);
          });
      });
  };

  $.fn.removeData = function (name) {
      return this.each(function () {
          removeData(this, name);
      });
  };

  $.fn.removeProp = function (name) {
      return this.each(function () {
          try {
              // @ts-ignore
              delete this[name];
          }
          catch (e) { }
      });
  };

  $.fn.replaceWith = function (newContent) {
      this.each(function (index, element) {
          var content = newContent;
          if (isFunction(content)) {
              content = content.call(element, index, element.innerHTML);
          }
          else if (index && !isString(content)) {
              content = $(content).clone();
          }
          $(element).before(content);
      });
      return this.remove();
  };

  $.fn.replaceAll = function (target) {
      var this$1 = this;

      return $(target).map(function (index, element) {
          $(element).replaceWith(index ? this$1.clone() : this$1);
          return this$1.get();
      });
  };

  /**
   * 将表单元素的值组合成键值对数组
   * @returns {Array}
   */
  $.fn.serializeArray = function () {
      var result = [];
      this.each(function (_, element) {
          var elements = element instanceof HTMLFormElement ? element.elements : [element];
          $(elements).each(function (_, element) {
              var $element = $(element);
              var type = element.type;
              var nodeName = element.nodeName.toLowerCase();
              if (nodeName !== 'fieldset' &&
                  element.name &&
                  !element.disabled &&
                  ['input', 'select', 'textarea', 'keygen'].indexOf(nodeName) > -1 &&
                  ['submit', 'button', 'image', 'reset', 'file'].indexOf(type) === -1 &&
                  (['radio', 'checkbox'].indexOf(type) === -1 ||
                      element.checked)) {
                  var value = $element.val();
                  var valueArr = Array.isArray(value) ? value : [value];
                  valueArr.forEach(function (value) {
                      result.push({
                          name: element.name,
                          value: value,
                      });
                  });
              }
          });
      });
      return result;
  };

  $.fn.serialize = function () {
      return param(this.serializeArray());
  };

  var elementDisplay = {};
  /**
   * 获取元素的初始 display 值，用于 .show() 方法
   * @param nodeName
   */
  function defaultDisplay(nodeName) {
      var element;
      var display;
      if (!elementDisplay[nodeName]) {
          element = document.createElement(nodeName);
          document.body.appendChild(element);
          display = getStyle(element, 'display');
          element.parentNode.removeChild(element);
          if (display === 'none') {
              display = 'block';
          }
          elementDisplay[nodeName] = display;
      }
      return elementDisplay[nodeName];
  }
  /**
   * 显示指定元素
   * @returns {JQ}
   */
  $.fn.show = function () {
      return this.each(function () {
          if (this.style.display === 'none') {
              this.style.display = '';
          }
          if (getStyle(this, 'display') === 'none') {
              this.style.display = defaultDisplay(this.nodeName);
          }
      });
  };

  /**
   * 取得同辈元素的集合
   * @param selector {String=}
   * @returns {JQ}
   */
  $.fn.siblings = function (selector) {
      return this.prevAll(selector).add(this.nextAll(selector));
  };

  /**
   * 切换元素的显示状态
   */
  $.fn.toggle = function () {
      return this.each(function () {
          getStyle(this, 'display') === 'none' ? $(this).show() : $(this).hide();
      });
  };

  $.fn.reflow = function () {
      return this.each(function () {
          return this.clientLeft;
      });
  };

  $.fn.transition = function (duration) {
      if (isNumber(duration)) {
          duration = duration + "ms";
      }
      return this.each(function () {
          this.style.webkitTransitionDuration = duration;
          this.style.transitionDuration = duration;
      });
  };

  $.fn.transitionEnd = function (callback) {
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      var events = ['webkitTransitionEnd', 'transitionend'];
      function fireCallback(e) {
          if (e.target !== this) {
              return;
          }
          // @ts-ignore
          callback.call(this, e);
          each(events, function (_, event) {
              that.off(event, fireCallback);
          });
      }
      each(events, function (_, event) {
          that.on(event, fireCallback);
      });
      return this;
  };

  $.fn.transformOrigin = function (transformOrigin) {
      return this.each(function () {
          this.style.webkitTransformOrigin = transformOrigin;
          this.style.transformOrigin = transformOrigin;
      });
  };

  $.fn.transform = function (transform) {
      return this.each(function () {
          this.style.webkitTransform = transform;
          this.style.transform = transform;
      });
  };

  /**
   * CSS 选择器和初始化函数组成的对象
   */
  var entries = {};
  /**
   * 注册并执行初始化函数
   * @param selector CSS 选择器
   * @param apiInit 初始化函数
   * @param i 元素索引
   * @param element 元素
   */
  function mutation(selector, apiInit, i, element) {
      var selectors = data(element, '_mdui_mutation');
      if (!selectors) {
          selectors = [];
          data(element, '_mdui_mutation', selectors);
      }
      if (selectors.indexOf(selector) === -1) {
          selectors.push(selector);
          apiInit.call(element, i, element);
      }
  }

  $.fn.mutation = function () {
      return this.each(function (i, element) {
          var $this = $(element);
          each(entries, function (selector, apiInit) {
              if ($this.is(selector)) {
                  mutation(selector, apiInit, i, element);
              }
              $this.find(selector).each(function (i, element) {
                  mutation(selector, apiInit, i, element);
              });
          });
      });
  };

  $.showOverlay = function (zIndex) {
      var $overlay = $('.mdui-overlay');
      if ($overlay.length) {
          $overlay.data('_overlay_is_deleted', false);
          if (!isUndefined(zIndex)) {
              $overlay.css('z-index', zIndex);
          }
      }
      else {
          if (isUndefined(zIndex)) {
              zIndex = 2000;
          }
          $overlay = $('<div class="mdui-overlay">')
              .appendTo(document.body)
              .reflow()
              .css('z-index', zIndex);
      }
      var level = $overlay.data('_overlay_level') || 0;
      return $overlay.data('_overlay_level', ++level).addClass('mdui-overlay-show');
  };

  $.hideOverlay = function (force) {
      if ( force === void 0 ) force = false;

      var $overlay = $('.mdui-overlay');
      if (!$overlay.length) {
          return;
      }
      var level = force ? 1 : $overlay.data('_overlay_level');
      if (level > 1) {
          $overlay.data('_overlay_level', --level);
          return;
      }
      $overlay
          .data('_overlay_level', 0)
          .removeClass('mdui-overlay-show')
          .data('_overlay_is_deleted', true)
          .transitionEnd(function () {
          if ($overlay.data('_overlay_is_deleted')) {
              $overlay.remove();
          }
      });
  };

  $.lockScreen = function () {
      var $body = $('body');
      // 不直接把 body 设为 box-sizing: border-box，避免污染全局样式
      var newBodyWidth = $body.width();
      var level = $body.data('_lockscreen_level') || 0;
      $body
          .addClass('mdui-locked')
          .width(newBodyWidth)
          .data('_lockscreen_level', ++level);
  };

  $.unlockScreen = function (force) {
      if ( force === void 0 ) force = false;

      var $body = $('body');
      var level = force ? 1 : $body.data('_lockscreen_level');
      if (level > 1) {
          $body.data('_lockscreen_level', --level);
          return;
      }
      $body.data('_lockscreen_level', 0).removeClass('mdui-locked').width('');
  };

  $.throttle = function (fn, delay) {
      if ( delay === void 0 ) delay = 16;

      var timer = null;
      return function () {
          var this$1 = this;
          var args = [], len = arguments.length;
          while ( len-- ) args[ len ] = arguments[ len ];

          if (isNull(timer)) {
              timer = setTimeout(function () {
                  fn.apply(this$1, args);
                  timer = null;
              }, delay);
          }
      };
  };

  var GUID = {};
  $.guid = function (name) {
      if (!isUndefined(name) && !isUndefined(GUID[name])) {
          return GUID[name];
      }
      function s4() {
          return Math.floor((1 + Math.random()) * 0x10000)
              .toString(16)
              .substring(1);
      }
      var guid = '_' +
          s4() +
          s4() +
          '-' +
          s4() +
          '-' +
          s4() +
          '-' +
          s4() +
          '-' +
          s4() +
          s4() +
          s4();
      if (!isUndefined(name)) {
          GUID[name] = guid;
      }
      return guid;
  };

  mdui.mutation = function (selector, apiInit) {
      if (isUndefined(selector) || isUndefined(apiInit)) {
          $(document).mutation();
          return;
      }
      entries[selector] = apiInit;
      $(selector).each(function (i, element) { return mutation(selector, apiInit, i, element); });
  };

  /**
   * 触发组件上的事件
   * @param eventName 事件名
   * @param componentName 组件名
   * @param target 在该元素上触发事件
   * @param instance 组件实例
   * @param parameters 事件参数
   */
  function componentEvent(eventName, componentName, target, instance, parameters) {
      if (!parameters) {
          parameters = {};
      }
      // @ts-ignore
      parameters.inst = instance;
      var fullEventName = eventName + ".mdui." + componentName;
      // jQuery 事件
      // @ts-ignore
      if (typeof jQuery !== 'undefined') {
          // @ts-ignore
          jQuery(target).trigger(fullEventName, parameters);
      }
      var $target = $(target);
      // mdui.jq 事件
      $target.trigger(fullEventName, parameters);
      var eventParams = {
          bubbles: true,
          cancelable: true,
          detail: parameters,
      };
      var eventObject = new CustomEvent(fullEventName, eventParams);
      // @ts-ignore
      eventObject._detail = parameters;
      $target[0].dispatchEvent(eventObject);
  }

  var $document = $(document);
  var $window = $(window);
  $('body');

  var DEFAULT_OPTIONS = {
      tolerance: 5,
      offset: 0,
      initialClass: 'mdui-headroom',
      pinnedClass: 'mdui-headroom-pinned-top',
      unpinnedClass: 'mdui-headroom-unpinned-top',
  };
  var Headroom = function Headroom(selector, options) {
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS);
      /**
       * 当前 headroom 的状态
       */
      this.state = 'pinned';
      /**
       * 当前是否启用
       */
      this.isEnable = false;
      /**
       * 上次滚动后，垂直方向的距离
       */
      this.lastScrollY = 0;
      /**
       * AnimationFrame ID
       */
      this.rafId = 0;
      this.$element = $(selector).first();
      extend(this.options, options);
      // tolerance 参数若为数值，转换为对象
      var tolerance = this.options.tolerance;
      if (isNumber(tolerance)) {
          this.options.tolerance = {
              down: tolerance,
              up: tolerance,
          };
      }
      this.enable();
  };
  /**
   * 滚动时的处理
   */
  Headroom.prototype.onScroll = function onScroll () {
          var this$1 = this;

      this.rafId = window.requestAnimationFrame(function () {
          var currentScrollY = window.pageYOffset;
          var direction = currentScrollY > this$1.lastScrollY ? 'down' : 'up';
          var tolerance = this$1.options.tolerance[direction];
          var scrolled = Math.abs(currentScrollY - this$1.lastScrollY);
          var toleranceExceeded = scrolled >= tolerance;
          if (currentScrollY > this$1.lastScrollY &&
              currentScrollY >= this$1.options.offset &&
              toleranceExceeded) {
              this$1.unpin();
          }
          else if ((currentScrollY < this$1.lastScrollY && toleranceExceeded) ||
              currentScrollY <= this$1.options.offset) {
              this$1.pin();
          }
          this$1.lastScrollY = currentScrollY;
      });
  };
  /**
   * 触发组件事件
   * @param name
   */
  Headroom.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'headroom', this.$element, this);
  };
  /**
   * 动画结束的回调
   */
  Headroom.prototype.transitionEnd = function transitionEnd () {
      if (this.state === 'pinning') {
          this.state = 'pinned';
          this.triggerEvent('pinned');
      }
      if (this.state === 'unpinning') {
          this.state = 'unpinned';
          this.triggerEvent('unpinned');
      }
  };
  /**
   * 使元素固定住
   */
  Headroom.prototype.pin = function pin () {
          var this$1 = this;

      if (this.state === 'pinning' ||
          this.state === 'pinned' ||
          !this.$element.hasClass(this.options.initialClass)) {
          return;
      }
      this.triggerEvent('pin');
      this.state = 'pinning';
      this.$element
          .removeClass(this.options.unpinnedClass)
          .addClass(this.options.pinnedClass)
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 使元素隐藏
   */
  Headroom.prototype.unpin = function unpin () {
          var this$1 = this;

      if (this.state === 'unpinning' ||
          this.state === 'unpinned' ||
          !this.$element.hasClass(this.options.initialClass)) {
          return;
      }
      this.triggerEvent('unpin');
      this.state = 'unpinning';
      this.$element
          .removeClass(this.options.pinnedClass)
          .addClass(this.options.unpinnedClass)
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 启用 headroom 插件
   */
  Headroom.prototype.enable = function enable () {
          var this$1 = this;

      if (this.isEnable) {
          return;
      }
      this.isEnable = true;
      this.state = 'pinned';
      this.$element
          .addClass(this.options.initialClass)
          .removeClass(this.options.pinnedClass)
          .removeClass(this.options.unpinnedClass);
      this.lastScrollY = window.pageYOffset;
      $window.on('scroll', function () { return this$1.onScroll(); });
  };
  /**
   * 禁用 headroom 插件
   */
  Headroom.prototype.disable = function disable () {
          var this$1 = this;

      if (!this.isEnable) {
          return;
      }
      this.isEnable = false;
      this.$element
          .removeClass(this.options.initialClass)
          .removeClass(this.options.pinnedClass)
          .removeClass(this.options.unpinnedClass);
      $window.off('scroll', function () { return this$1.onScroll(); });
      window.cancelAnimationFrame(this.rafId);
  };
  /**
   * 获取当前状态。共包含四种状态：`pinning`、`pinned`、`unpinning`、`unpinned`
   */
  Headroom.prototype.getState = function getState () {
      return this.state;
  };
  mdui.Headroom = Headroom;

  /**
   * 解析 DATA API 参数
   * @param element 元素
   * @param name 属性名
   */
  function parseOptions(element, name) {
      var attr = $(element).attr(name);
      if (!attr) {
          return {};
      }
      return new Function('', ("var json = " + attr + "; return JSON.parse(JSON.stringify(json));"))();
  }

  var customAttr = 'mdui-headroom';
  $(function () {
      mdui.mutation(("[" + customAttr + "]"), function () {
          new mdui.Headroom(this, parseOptions(this, customAttr));
      });
  });

  var DEFAULT_OPTIONS$1 = {
      accordion: false,
  };
  var CollapseAbstract = function CollapseAbstract(selector, options) {
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$1);
      // CSS 类名
      var classPrefix = "mdui-" + (this.getNamespace()) + "-item";
      this.classItem = classPrefix;
      this.classItemOpen = classPrefix + "-open";
      this.classHeader = classPrefix + "-header";
      this.classBody = classPrefix + "-body";
      this.$element = $(selector).first();
      extend(this.options, options);
      this.bindEvent();
  };
  /**
   * 绑定事件
   */
  CollapseAbstract.prototype.bindEvent = function bindEvent () {
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      // 点击 header 时，打开/关闭 item
      this.$element.on('click', ("." + (this.classHeader)), function () {
          var $header = $(this);
          var $item = $header.parent();
          var $items = that.getItems();
          $items.each(function (_, item) {
              if ($item.is(item)) {
                  that.toggle(item);
              }
          });
      });
      // 点击关闭按钮时，关闭 item
      this.$element.on('click', ("[mdui-" + (this.getNamespace()) + "-item-close]"), function () {
          var $target = $(this);
          var $item = $target.parents(("." + (that.classItem))).first();
          that.close($item);
      });
  };
  /**
   * 指定 item 是否处于打开状态
   * @param $item
   */
  CollapseAbstract.prototype.isOpen = function isOpen ($item) {
      return $item.hasClass(this.classItemOpen);
  };
  /**
   * 获取所有 item
   */
  CollapseAbstract.prototype.getItems = function getItems () {
      return this.$element.children(("." + (this.classItem)));
  };
  /**
   * 获取指定 item
   * @param item
   */
  CollapseAbstract.prototype.getItem = function getItem (item) {
      if (isNumber(item)) {
          return this.getItems().eq(item);
      }
      return $(item).first();
  };
  /**
   * 触发组件事件
   * @param name 事件名
   * @param $item 事件触发的目标 item
   */
  CollapseAbstract.prototype.triggerEvent = function triggerEvent (name, $item) {
      componentEvent(name, this.getNamespace(), $item, this);
  };
  /**
   * 动画结束回调
   * @param $content body 元素
   * @param $item item 元素
   */
  CollapseAbstract.prototype.transitionEnd = function transitionEnd ($content, $item) {
      if (this.isOpen($item)) {
          $content.transition(0).height('auto').reflow().transition('');
          this.triggerEvent('opened', $item);
      }
      else {
          $content.height('');
          this.triggerEvent('closed', $item);
      }
  };
  /**
   * 打开指定面板项
   * @param item 面板项的索引号、或 CSS 选择器、或 DOM 元素、或 JQ 对象
   */
  CollapseAbstract.prototype.open = function open (item) {
          var this$1 = this;

      var $item = this.getItem(item);
      if (this.isOpen($item)) {
          return;
      }
      // 关闭其他项
      if (this.options.accordion) {
          this.$element.children(("." + (this.classItemOpen))).each(function (_, element) {
              var $element = $(element);
              if (!$element.is($item)) {
                  this$1.close($element);
              }
          });
      }
      var $content = $item.children(("." + (this.classBody)));
      $content
          .height($content[0].scrollHeight)
          .transitionEnd(function () { return this$1.transitionEnd($content, $item); });
      this.triggerEvent('open', $item);
      $item.addClass(this.classItemOpen);
  };
  /**
   * 关闭指定面板项
   * @param item 面板项的索引号、或 CSS 选择器、或 DOM 元素、或 JQ 对象
   */
  CollapseAbstract.prototype.close = function close (item) {
          var this$1 = this;

      var $item = this.getItem(item);
      if (!this.isOpen($item)) {
          return;
      }
      var $content = $item.children(("." + (this.classBody)));
      this.triggerEvent('close', $item);
      $item.removeClass(this.classItemOpen);
      $content
          .transition(0)
          .height($content[0].scrollHeight)
          .reflow()
          .transition('')
          .height('')
          .transitionEnd(function () { return this$1.transitionEnd($content, $item); });
  };
  /**
   * 切换指定面板项的打开状态
   * @param item 面板项的索引号、或 CSS 选择器、或 DOM 元素、或 JQ 对象
   */
  CollapseAbstract.prototype.toggle = function toggle (item) {
      var $item = this.getItem(item);
      this.isOpen($item) ? this.close($item) : this.open($item);
  };
  /**
   * 打开所有面板项
   */
  CollapseAbstract.prototype.openAll = function openAll () {
          var this$1 = this;

      this.getItems().each(function (_, element) { return this$1.open(element); });
  };
  /**
   * 关闭所有面板项
   */
  CollapseAbstract.prototype.closeAll = function closeAll () {
          var this$1 = this;

      this.getItems().each(function (_, element) { return this$1.close(element); });
  };

  var Collapse = /*@__PURE__*/(function (CollapseAbstract) {
      function Collapse () {
          CollapseAbstract.apply(this, arguments);
      }

      if ( CollapseAbstract ) Collapse.__proto__ = CollapseAbstract;
      Collapse.prototype = Object.create( CollapseAbstract && CollapseAbstract.prototype );
      Collapse.prototype.constructor = Collapse;

      Collapse.prototype.getNamespace = function getNamespace () {
          return 'collapse';
      };

      return Collapse;
  }(CollapseAbstract));
  mdui.Collapse = Collapse;

  var customAttr$1 = 'mdui-collapse';
  $(function () {
      mdui.mutation(("[" + customAttr$1 + "]"), function () {
          new mdui.Collapse(this, parseOptions(this, customAttr$1));
      });
  });

  var Panel = /*@__PURE__*/(function (CollapseAbstract) {
      function Panel () {
          CollapseAbstract.apply(this, arguments);
      }

      if ( CollapseAbstract ) Panel.__proto__ = CollapseAbstract;
      Panel.prototype = Object.create( CollapseAbstract && CollapseAbstract.prototype );
      Panel.prototype.constructor = Panel;

      Panel.prototype.getNamespace = function getNamespace () {
          return 'panel';
      };

      return Panel;
  }(CollapseAbstract));
  mdui.Panel = Panel;

  var customAttr$2 = 'mdui-panel';
  $(function () {
      mdui.mutation(("[" + customAttr$2 + "]"), function () {
          new mdui.Panel(this, parseOptions(this, customAttr$2));
      });
  });

  var Table = function Table(selector) {
      /**
       * 表头 tr 元素
       */
      this.$thRow = $();
      /**
       * 表格 body 中的 tr 元素
       */
      this.$tdRows = $();
      /**
       * 表头的 checkbox 元素
       */
      this.$thCheckbox = $();
      /**
       * 表格 body 中的 checkbox 元素
       */
      this.$tdCheckboxs = $();
      /**
       * 表格行是否可选择
       */
      this.selectable = false;
      /**
       * 已选中的行数
       */
      this.selectedRow = 0;
      this.$element = $(selector).first();
      this.init();
  };
  /**
   * 初始化表格
   */
  Table.prototype.init = function init () {
      this.$thRow = this.$element.find('thead tr');
      this.$tdRows = this.$element.find('tbody tr');
      this.selectable = this.$element.hasClass('mdui-table-selectable');
      this.updateThCheckbox();
      this.updateTdCheckbox();
      this.updateNumericCol();
  };
  /**
   * 生成 checkbox 的 HTML 结构
   * @param tag 标签名
   */
  Table.prototype.createCheckboxHTML = function createCheckboxHTML (tag) {
      return ("<" + tag + " class=\"mdui-table-cell-checkbox\">" +
          '<label class="mdui-checkbox">' +
          '<input type="checkbox"/>' +
          '<i class="mdui-checkbox-icon"></i>' +
          '</label>' +
          "</" + tag + ">");
  };
  /**
   * 更新表头 checkbox 的状态
   */
  Table.prototype.updateThCheckboxStatus = function updateThCheckboxStatus () {
      var checkbox = this.$thCheckbox[0];
      var selectedRow = this.selectedRow;
      var tdRowsLength = this.$tdRows.length;
      checkbox.checked = selectedRow === tdRowsLength;
      checkbox.indeterminate = !!selectedRow && selectedRow !== tdRowsLength;
  };
  /**
   * 更新表格行的 checkbox
   */
  Table.prototype.updateTdCheckbox = function updateTdCheckbox () {
          var this$1 = this;

      var rowSelectedClass = 'mdui-table-row-selected';
      this.$tdRows.each(function (_, row) {
          var $row = $(row);
          // 移除旧的 checkbox
          $row.find('.mdui-table-cell-checkbox').remove();
          if (!this$1.selectable) {
              return;
          }
          // 创建 DOM
          var $checkbox = $(this$1.createCheckboxHTML('td'))
              .prependTo($row)
              .find('input[type="checkbox"]');
          // 默认选中的行
          if ($row.hasClass(rowSelectedClass)) {
              $checkbox[0].checked = true;
              this$1.selectedRow++;
          }
          this$1.updateThCheckboxStatus();
          // 绑定事件
          $checkbox.on('change', function () {
              if ($checkbox[0].checked) {
                  $row.addClass(rowSelectedClass);
                  this$1.selectedRow++;
              }
              else {
                  $row.removeClass(rowSelectedClass);
                  this$1.selectedRow--;
              }
              this$1.updateThCheckboxStatus();
          });
          this$1.$tdCheckboxs = this$1.$tdCheckboxs.add($checkbox);
      });
  };
  /**
   * 更新表头的 checkbox
   */
  Table.prototype.updateThCheckbox = function updateThCheckbox () {
          var this$1 = this;

      // 移除旧的 checkbox
      this.$thRow.find('.mdui-table-cell-checkbox').remove();
      if (!this.selectable) {
          return;
      }
      this.$thCheckbox = $(this.createCheckboxHTML('th'))
          .prependTo(this.$thRow)
          .find('input[type="checkbox"]')
          .on('change', function () {
          var isCheckedAll = this$1.$thCheckbox[0].checked;
          this$1.selectedRow = isCheckedAll ? this$1.$tdRows.length : 0;
          this$1.$tdCheckboxs.each(function (_, checkbox) {
              checkbox.checked = isCheckedAll;
          });
          this$1.$tdRows.each(function (_, row) {
              isCheckedAll
                  ? $(row).addClass('mdui-table-row-selected')
                  : $(row).removeClass('mdui-table-row-selected');
          });
      });
  };
  /**
   * 更新数值列
   */
  Table.prototype.updateNumericCol = function updateNumericCol () {
          var this$1 = this;

      var numericClass = 'mdui-table-col-numeric';
      this.$thRow.find('th').each(function (i, th) {
          var isNumericCol = $(th).hasClass(numericClass);
          this$1.$tdRows.each(function (_, row) {
              var $td = $(row).find('td').eq(i);
              isNumericCol
                  ? $td.addClass(numericClass)
                  : $td.removeClass(numericClass);
          });
      });
  };
  var dataName = '_mdui_table';
  $(function () {
      mdui.mutation('.mdui-table', function () {
          var $element = $(this);
          if (!$element.data(dataName)) {
              $element.data(dataName, new Table($element));
          }
      });
  });
  mdui.updateTables = function (selector) {
      var $elements = isUndefined(selector) ? $('.mdui-table') : $(selector);
      $elements.each(function (_, element) {
          var $element = $(element);
          var instance = $element.data(dataName);
          if (instance) {
              instance.init();
          }
          else {
              $element.data(dataName, new Table($element));
          }
      });
  };

  /**
   * touch 事件后的 500ms 内禁用 mousedown 事件
   *
   * 不支持触控的屏幕上事件顺序为 mousedown -> mouseup -> click
   * 支持触控的屏幕上事件顺序为 touchstart -> touchend -> mousedown -> mouseup -> click
   *
   * 在每一个事件中都使用 TouchHandler.isAllow(event) 判断事件是否可执行
   * 在 touchstart 和 touchmove、touchend、touchcancel
   *
   * (function () {
   *   $document
   *     .on(start, function (e) {
   *       if (!isAllow(e)) {
   *         return;
   *       }
   *       register(e);
   *       console.log(e.type);
   *     })
   *     .on(move, function (e) {
   *       if (!isAllow(e)) {
   *         return;
   *       }
   *       console.log(e.type);
   *     })
   *     .on(end, function (e) {
   *       if (!isAllow(e)) {
   *         return;
   *       }
   *       console.log(e.type);
   *     })
   *     .on(unlock, register);
   * })();
   */
  var startEvent = 'touchstart mousedown';
  var moveEvent = 'touchmove mousemove';
  var endEvent = 'touchend mouseup';
  var cancelEvent = 'touchcancel mouseleave';
  var unlockEvent = 'touchend touchmove touchcancel';
  var touches = 0;
  /**
   * 该事件是否被允许，在执行事件前调用该方法判断事件是否可以执行
   * 若已触发 touch 事件，则阻止之后的鼠标事件
   * @param event
   */
  function isAllow(event) {
      return !(touches &&
          [
              'mousedown',
              'mouseup',
              'mousemove',
              'click',
              'mouseover',
              'mouseout',
              'mouseenter',
              'mouseleave' ].indexOf(event.type) > -1);
  }
  /**
   * 在 touchstart 和 touchmove、touchend、touchcancel 事件中调用该方法注册事件
   * @param event
   */
  function register(event) {
      if (event.type === 'touchstart') {
          // 触发了 touch 事件
          touches += 1;
      }
      else if (['touchmove', 'touchend', 'touchcancel'].indexOf(event.type) > -1) {
          // touch 事件结束 500ms 后解除对鼠标事件的阻止
          setTimeout(function () {
              if (touches) {
                  touches -= 1;
              }
          }, 500);
      }
  }

  /**
   * Inspired by https://github.com/nolimits4web/Framework7/blob/master/src/js/fast-clicks.js
   * https://github.com/nolimits4web/Framework7/blob/master/LICENSE
   *
   * Inspired by https://github.com/fians/Waves
   */
  /**
   * 显示涟漪动画
   * @param event
   * @param $ripple
   */
  function show(event, $ripple) {
      // 鼠标右键不产生涟漪
      if (event instanceof MouseEvent && event.button === 2) {
          return;
      }
      // 点击位置坐标
      var touchPosition = typeof TouchEvent !== 'undefined' &&
          event instanceof TouchEvent &&
          event.touches.length
          ? event.touches[0]
          : event;
      var touchStartX = touchPosition.pageX;
      var touchStartY = touchPosition.pageY;
      // 涟漪位置
      var offset = $ripple.offset();
      var height = $ripple.innerHeight();
      var width = $ripple.innerWidth();
      var center = {
          x: touchStartX - offset.left,
          y: touchStartY - offset.top,
      };
      var diameter = Math.max(Math.pow(Math.pow(height, 2) + Math.pow(width, 2), 0.5), 48);
      // 涟漪扩散动画
      var translate = "translate3d(" + (-center.x + width / 2) + "px," +
          (-center.y + height / 2) + "px, 0) scale(1)";
      // 涟漪的 DOM 结构，并缓存动画效果
      $("<div class=\"mdui-ripple-wave\" " +
          "style=\"width:" + diameter + "px;height:" + diameter + "px;" +
          "margin-top:-" + (diameter / 2) + "px;margin-left:-" + (diameter / 2) + "px;" +
          "left:" + (center.x) + "px;top:" + (center.y) + "px;\"></div>")
          .data('_ripple_wave_translate', translate)
          .prependTo($ripple)
          .reflow()
          .transform(translate);
  }
  /**
   * 隐藏并移除涟漪
   * @param $wave
   */
  function removeRipple($wave) {
      if (!$wave.length || $wave.data('_ripple_wave_removed')) {
          return;
      }
      $wave.data('_ripple_wave_removed', true);
      var removeTimer = setTimeout(function () { return $wave.remove(); }, 400);
      var translate = $wave.data('_ripple_wave_translate');
      $wave
          .addClass('mdui-ripple-wave-fill')
          .transform(translate.replace('scale(1)', 'scale(1.01)'))
          .transitionEnd(function () {
          clearTimeout(removeTimer);
          $wave
              .addClass('mdui-ripple-wave-out')
              .transform(translate.replace('scale(1)', 'scale(1.01)'));
          removeTimer = setTimeout(function () { return $wave.remove(); }, 700);
          setTimeout(function () {
              $wave.transitionEnd(function () {
                  clearTimeout(removeTimer);
                  $wave.remove();
              });
          }, 0);
      });
  }
  /**
   * 隐藏涟漪动画
   * @param this
   */
  function hide() {
      var $ripple = $(this);
      $ripple.children('.mdui-ripple-wave').each(function (_, wave) {
          removeRipple($(wave));
      });
      $ripple.off((moveEvent + " " + endEvent + " " + cancelEvent), hide);
  }
  /**
   * 显示涟漪，并绑定 touchend 等事件
   * @param event
   */
  function showRipple(event) {
      if (!isAllow(event)) {
          return;
      }
      register(event);
      // Chrome 59 点击滚动条时，会在 document 上触发事件
      if (event.target === document) {
          return;
      }
      var $target = $(event.target);
      // 获取含 .mdui-ripple 类的元素
      var $ripple = $target.hasClass('mdui-ripple')
          ? $target
          : $target.parents('.mdui-ripple').first();
      if (!$ripple.length) {
          return;
      }
      // 禁用状态的元素上不产生涟漪效果
      if ($ripple.prop('disabled') || !isUndefined($ripple.attr('disabled'))) {
          return;
      }
      if (event.type === 'touchstart') {
          var hidden = false;
          // touchstart 触发指定时间后开始涟漪动画，避免手指滑动时也触发涟漪
          var timer = setTimeout(function () {
              timer = 0;
              show(event, $ripple);
          }, 200);
          var hideRipple = function () {
              // 如果手指没有移动，且涟漪动画还没有开始，则开始涟漪动画
              if (timer) {
                  clearTimeout(timer);
                  timer = 0;
                  show(event, $ripple);
              }
              if (!hidden) {
                  hidden = true;
                  hide.call($ripple);
              }
          };
          // 手指移动后，移除涟漪动画
          var touchMove = function () {
              if (timer) {
                  clearTimeout(timer);
                  timer = 0;
              }
              hideRipple();
          };
          $ripple.on('touchmove', touchMove).on('touchend touchcancel', hideRipple);
      }
      else {
          show(event, $ripple);
          $ripple.on((moveEvent + " " + endEvent + " " + cancelEvent), hide);
      }
  }
  $(function () {
      $document.on(startEvent, showRipple).on(unlockEvent, register);
  });

  var defaultData = {
      reInit: false,
      domLoadedEvent: false,
  };
  /**
   * 输入框事件
   * @param event
   * @param data
   */
  function inputEvent(event, data) {
      if ( data === void 0 ) data = {};

      data = extend({}, defaultData, data);
      var input = event.target;
      var $input = $(input);
      var eventType = event.type;
      var value = $input.val();
      // 文本框类型
      var inputType = $input.attr('type') || '';
      if (['checkbox', 'button', 'submit', 'range', 'radio', 'image'].indexOf(inputType) > -1) {
          return;
      }
      var $textfield = $input.parent('.mdui-textfield');
      // 输入框是否聚焦
      if (eventType === 'focus') {
          $textfield.addClass('mdui-textfield-focus');
      }
      if (eventType === 'blur') {
          $textfield.removeClass('mdui-textfield-focus');
      }
      // 输入框是否为空
      if (eventType === 'blur' || eventType === 'input') {
          value
              ? $textfield.addClass('mdui-textfield-not-empty')
              : $textfield.removeClass('mdui-textfield-not-empty');
      }
      // 输入框是否禁用
      input.disabled
          ? $textfield.addClass('mdui-textfield-disabled')
          : $textfield.removeClass('mdui-textfield-disabled');
      // 表单验证
      if ((eventType === 'input' || eventType === 'blur') &&
          !data.domLoadedEvent &&
          input.validity) {
          input.validity.valid
              ? $textfield.removeClass('mdui-textfield-invalid-html5')
              : $textfield.addClass('mdui-textfield-invalid-html5');
      }
      // textarea 高度自动调整
      if ($input.is('textarea')) {
          // IE bug：textarea 的值仅为多个换行，不含其他内容时，textarea 的高度不准确
          //         此时，在计算高度前，在值的开头加入一个空格，计算完后，移除空格
          var inputValue = value;
          var hasExtraSpace = false;
          if (inputValue.replace(/[\r\n]/g, '') === '') {
              $input.val(' ' + inputValue);
              hasExtraSpace = true;
          }
          // 设置 textarea 高度
          $input.outerHeight('');
          var height = $input.outerHeight();
          var scrollHeight = input.scrollHeight;
          if (scrollHeight > height) {
              $input.outerHeight(scrollHeight);
          }
          // 计算完，还原 textarea 的值
          if (hasExtraSpace) {
              $input.val(inputValue);
          }
      }
      // 实时字数统计
      if (data.reInit) {
          $textfield.find('.mdui-textfield-counter').remove();
      }
      var maxLength = $input.attr('maxlength');
      if (maxLength) {
          if (data.reInit || data.domLoadedEvent) {
              $('<div class="mdui-textfield-counter">' +
                  "<span class=\"mdui-textfield-counter-inputed\"></span> / " + maxLength +
                  '</div>').appendTo($textfield);
          }
          $textfield
              .find('.mdui-textfield-counter-inputed')
              .text(value.length.toString());
      }
      // 含 帮助文本、错误提示、字数统计 时，增加文本框底部内边距
      if ($textfield.find('.mdui-textfield-helper').length ||
          $textfield.find('.mdui-textfield-error').length ||
          maxLength) {
          $textfield.addClass('mdui-textfield-has-bottom');
      }
  }
  $(function () {
      // 绑定事件
      $document.on('input focus blur', '.mdui-textfield-input', { useCapture: true }, inputEvent);
      // 可展开文本框展开
      $document.on('click', '.mdui-textfield-expandable .mdui-textfield-icon', function () {
          $(this)
              .parents('.mdui-textfield')
              .addClass('mdui-textfield-expanded')
              .find('.mdui-textfield-input')[0]
              .focus();
      });
      // 可展开文本框关闭
      $document.on('click', '.mdui-textfield-expanded .mdui-textfield-close', function () {
          $(this)
              .parents('.mdui-textfield')
              .removeClass('mdui-textfield-expanded')
              .find('.mdui-textfield-input')
              .val('');
      });
      /**
       * 初始化文本框
       */
      mdui.mutation('.mdui-textfield', function () {
          $(this).find('.mdui-textfield-input').trigger('input', {
              domLoadedEvent: true,
          });
      });
  });
  mdui.updateTextFields = function (selector) {
      var $elements = isUndefined(selector) ? $('.mdui-textfield') : $(selector);
      $elements.each(function (_, element) {
          $(element).find('.mdui-textfield-input').trigger('input', {
              reInit: true,
          });
      });
  };

  /**
   * 滑块的值改变后修改滑块样式
   * @param $slider
   */
  function updateValueStyle($slider) {
      var data = $slider.data();
      var $track = data._slider_$track;
      var $fill = data._slider_$fill;
      var $thumb = data._slider_$thumb;
      var $input = data._slider_$input;
      var min = data._slider_min;
      var max = data._slider_max;
      var isDisabled = data._slider_disabled;
      var isDiscrete = data._slider_discrete;
      var $thumbText = data._slider_$thumbText;
      var value = $input.val();
      var percent = ((value - min) / (max - min)) * 100;
      $fill.width((percent + "%"));
      $track.width(((100 - percent) + "%"));
      if (isDisabled) {
          $fill.css('padding-right', '6px');
          $track.css('padding-left', '6px');
      }
      $thumb.css('left', (percent + "%"));
      if (isDiscrete) {
          $thumbText.text(value);
      }
      percent === 0
          ? $slider.addClass('mdui-slider-zero')
          : $slider.removeClass('mdui-slider-zero');
  }
  /**
   * 重新初始化滑块
   * @param $slider
   */
  function reInit($slider) {
      var $track = $('<div class="mdui-slider-track"></div>');
      var $fill = $('<div class="mdui-slider-fill"></div>');
      var $thumb = $('<div class="mdui-slider-thumb"></div>');
      var $input = $slider.find('input[type="range"]');
      var isDisabled = $input[0].disabled;
      var isDiscrete = $slider.hasClass('mdui-slider-discrete');
      // 禁用状态
      isDisabled
          ? $slider.addClass('mdui-slider-disabled')
          : $slider.removeClass('mdui-slider-disabled');
      // 重新填充 HTML
      $slider.find('.mdui-slider-track').remove();
      $slider.find('.mdui-slider-fill').remove();
      $slider.find('.mdui-slider-thumb').remove();
      $slider.append($track).append($fill).append($thumb);
      // 间续型滑块
      var $thumbText = $();
      if (isDiscrete) {
          $thumbText = $('<span></span>');
          $thumb.empty().append($thumbText);
      }
      $slider.data('_slider_$track', $track);
      $slider.data('_slider_$fill', $fill);
      $slider.data('_slider_$thumb', $thumb);
      $slider.data('_slider_$input', $input);
      $slider.data('_slider_min', $input.attr('min'));
      $slider.data('_slider_max', $input.attr('max'));
      $slider.data('_slider_disabled', isDisabled);
      $slider.data('_slider_discrete', isDiscrete);
      $slider.data('_slider_$thumbText', $thumbText);
      // 设置默认值
      updateValueStyle($slider);
  }
  var rangeSelector = '.mdui-slider input[type="range"]';
  $(function () {
      // 滑块滑动事件
      $document.on('input change', rangeSelector, function () {
          var $slider = $(this).parent();
          updateValueStyle($slider);
      });
      // 开始触摸滑块事件
      $document.on(startEvent, rangeSelector, function (event) {
          if (!isAllow(event)) {
              return;
          }
          register(event);
          if (this.disabled) {
              return;
          }
          var $slider = $(this).parent();
          $slider.addClass('mdui-slider-focus');
      });
      // 结束触摸滑块事件
      $document.on(endEvent, rangeSelector, function (event) {
          if (!isAllow(event)) {
              return;
          }
          if (this.disabled) {
              return;
          }
          var $slider = $(this).parent();
          $slider.removeClass('mdui-slider-focus');
      });
      $document.on(unlockEvent, rangeSelector, register);
      /**
       * 初始化滑块
       */
      mdui.mutation('.mdui-slider', function () {
          reInit($(this));
      });
  });
  mdui.updateSliders = function (selector) {
      var $elements = isUndefined(selector) ? $('.mdui-slider') : $(selector);
      $elements.each(function (_, element) {
          reInit($(element));
      });
  };

  var DEFAULT_OPTIONS$2 = {
      trigger: 'hover',
  };
  var Fab = function Fab(selector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$2);
      /**
       * 当前 fab 的状态
       */
      this.state = 'closed';
      this.$element = $(selector).first();
      extend(this.options, options);
      this.$btn = this.$element.find('.mdui-fab');
      this.$dial = this.$element.find('.mdui-fab-dial');
      this.$dialBtns = this.$dial.find('.mdui-fab');
      if (this.options.trigger === 'hover') {
          this.$btn.on('touchstart mouseenter', function () { return this$1.open(); });
          this.$element.on('mouseleave', function () { return this$1.close(); });
      }
      if (this.options.trigger === 'click') {
          this.$btn.on(startEvent, function () { return this$1.open(); });
      }
      // 触摸屏幕其他地方关闭快速拨号
      $document.on(startEvent, function (event) {
          if ($(event.target).parents('.mdui-fab-wrapper').length) {
              return;
          }
          this$1.close();
      });
  };
  /**
   * 触发组件事件
   * @param name
   */
  Fab.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'fab', this.$element, this);
  };
  /**
   * 当前是否为打开状态
   */
  Fab.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 打开快速拨号菜单
   */
  Fab.prototype.open = function open () {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      // 为菜单中的按钮添加不同的 transition-delay
      this.$dialBtns.each(function (index, btn) {
          var delay = (15 * (this$1.$dialBtns.length - index)) + "ms";
          btn.style.transitionDelay = delay;
          btn.style.webkitTransitionDelay = delay;
      });
      this.$dial.css('height', 'auto').addClass('mdui-fab-dial-show');
      // 如果按钮中存在 .mdui-fab-opened 的图标，则进行图标切换
      if (this.$btn.find('.mdui-fab-opened').length) {
          this.$btn.addClass('mdui-fab-opened');
      }
      this.state = 'opening';
      this.triggerEvent('open');
      // 打开顺序为从下到上逐个打开，最上面的打开后才表示动画完成
      this.$dialBtns.first().transitionEnd(function () {
          if (this$1.$btn.hasClass('mdui-fab-opened')) {
              this$1.state = 'opened';
              this$1.triggerEvent('opened');
          }
      });
  };
  /**
   * 关闭快速拨号菜单
   */
  Fab.prototype.close = function close () {
          var this$1 = this;

      if (!this.isOpen()) {
          return;
      }
      // 为菜单中的按钮添加不同的 transition-delay
      this.$dialBtns.each(function (index, btn) {
          var delay = (15 * index) + "ms";
          btn.style.transitionDelay = delay;
          btn.style.webkitTransitionDelay = delay;
      });
      this.$dial.removeClass('mdui-fab-dial-show');
      this.$btn.removeClass('mdui-fab-opened');
      this.state = 'closing';
      this.triggerEvent('close');
      // 从上往下依次关闭，最后一个关闭后才表示动画完成
      this.$dialBtns.last().transitionEnd(function () {
          if (this$1.$btn.hasClass('mdui-fab-opened')) {
              return;
          }
          this$1.state = 'closed';
          this$1.triggerEvent('closed');
          this$1.$dial.css('height', 0);
      });
  };
  /**
   * 切换快速拨号菜单的打开状态
   */
  Fab.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 以动画的形式显示整个浮动操作按钮
   */
  Fab.prototype.show = function show () {
      this.$element.removeClass('mdui-fab-hide');
  };
  /**
   * 以动画的形式隐藏整个浮动操作按钮
   */
  Fab.prototype.hide = function hide () {
      this.$element.addClass('mdui-fab-hide');
  };
  /**
   * 返回当前快速拨号菜单的打开状态。共包含四种状态：`opening`、`opened`、`closing`、`closed`
   */
  Fab.prototype.getState = function getState () {
      return this.state;
  };
  mdui.Fab = Fab;

  var customAttr$3 = 'mdui-fab';
  $(function () {
      // mouseenter 不冒泡，无法进行事件委托，这里用 mouseover 代替。
      // 不管是 click 、 mouseover 还是 touchstart ，都先初始化。
      $document.on('touchstart mousedown mouseover', ("[" + customAttr$3 + "]"), function () {
          new mdui.Fab(this, parseOptions(this, customAttr$3));
      });
  });

  /**
   * 最终生成的元素结构为：
   *  <select class="mdui-select" mdui-select="{position: 'top'}" style="display: none;"> // $native
   *    <option value="1">State 1</option>
   *    <option value="2">State 2</option>
   *    <option value="3" disabled="">State 3</option>
   *  </select>
   *  <div class="mdui-select mdui-select-position-top" style="" id="88dec0e4-d4a2-c6d0-0e7f-1ba4501e0553"> // $element
   *    <span class="mdui-select-selected">State 1</span> // $selected
   *    <div class="mdui-select-menu" style="transform-origin: center 100% 0px;"> // $menu
   *      <div class="mdui-select-menu-item mdui-ripple" selected="">State 1</div> // $items
   *      <div class="mdui-select-menu-item mdui-ripple">State 2</div>
   *      <div class="mdui-select-menu-item mdui-ripple" disabled="">State 3</div>
   *    </div>
   *  </div>
   */
  var DEFAULT_OPTIONS$3 = {
      position: 'auto',
      gutter: 16,
  };
  var Select = function Select(selector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 生成的 `<div class="mdui-select">` 元素的 JQ 对象
       */
      this.$element = $();
      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$3);
      /**
       * select 的 size 属性的值，根据该值设置 select 的高度
       */
      this.size = 0;
      /**
       * 占位元素，显示已选中菜单项的文本
       */
      this.$selected = $();
      /**
       * 菜单项的外层元素的 JQ 对象
       */
      this.$menu = $();
      /**
       * 菜单项数组的 JQ 对象
       */
      this.$items = $();
      /**
       * 当前选中的菜单项的索引号
       */
      this.selectedIndex = 0;
      /**
       * 当前选中菜单项的文本
       */
      this.selectedText = '';
      /**
       * 当前选中菜单项的值
       */
      this.selectedValue = '';
      /**
       * 当前 select 的状态
       */
      this.state = 'closed';
      this.$native = $(selector).first();
      this.$native.hide();
      extend(this.options, options);
      // 为当前 select 生成唯一 ID
      this.uniqueID = $.guid();
      // 生成 select
      this.handleUpdate();
      // 点击 select 外面区域关闭
      $document.on('click touchstart', function (event) {
          var $target = $(event.target);
          if (this$1.isOpen() &&
              !$target.is(this$1.$element) &&
              !contains(this$1.$element[0], $target[0])) {
              this$1.close();
          }
      });
  };
  /**
   * 调整菜单位置
   */
  Select.prototype.readjustMenu = function readjustMenu () {
      var windowHeight = $window.height();
      // mdui-select 高度
      var elementHeight = this.$element.height();
      // 菜单项高度
      var $itemFirst = this.$items.first();
      var itemHeight = $itemFirst.height();
      var itemMargin = parseInt($itemFirst.css('margin-top'));
      // 菜单高度
      var menuWidth = this.$element.innerWidth() + 0.01; // 必须比真实宽度多一点，不然会出现省略号
      var menuHeight = itemHeight * this.size + itemMargin * 2;
      // mdui-select 在窗口中的位置
      var elementTop = this.$element[0].getBoundingClientRect().top;
      var transformOriginY;
      var menuMarginTop;
      if (this.options.position === 'bottom') {
          menuMarginTop = elementHeight;
          transformOriginY = '0px';
      }
      else if (this.options.position === 'top') {
          menuMarginTop = -menuHeight - 1;
          transformOriginY = '100%';
      }
      else {
          // 菜单高度不能超过窗口高度
          var menuMaxHeight = windowHeight - this.options.gutter * 2;
          if (menuHeight > menuMaxHeight) {
              menuHeight = menuMaxHeight;
          }
          // 菜单的 margin-top
          menuMarginTop = -(itemMargin +
              this.selectedIndex * itemHeight +
              (itemHeight - elementHeight) / 2);
          var menuMaxMarginTop = -(itemMargin +
              (this.size - 1) * itemHeight +
              (itemHeight - elementHeight) / 2);
          if (menuMarginTop < menuMaxMarginTop) {
              menuMarginTop = menuMaxMarginTop;
          }
          // 菜单不能超出窗口
          var menuTop = elementTop + menuMarginTop;
          if (menuTop < this.options.gutter) {
              // 不能超出窗口上方
              menuMarginTop = -(elementTop - this.options.gutter);
          }
          else if (menuTop + menuHeight + this.options.gutter > windowHeight) {
              // 不能超出窗口下方
              menuMarginTop = -(elementTop +
                  menuHeight +
                  this.options.gutter -
                  windowHeight);
          }
          // transform 的 Y 轴坐标
          transformOriginY = (this.selectedIndex * itemHeight + itemHeight / 2 + itemMargin) + "px";
      }
      // 设置样式
      this.$element.innerWidth(menuWidth);
      this.$menu
          .innerWidth(menuWidth)
          .height(menuHeight)
          .css({
          'margin-top': menuMarginTop + 'px',
          'transform-origin': 'center ' + transformOriginY + ' 0',
      });
  };
  /**
   * select 是否为打开状态
   */
  Select.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 对原生 select 组件进行了修改后，需要调用该方法
   */
  Select.prototype.handleUpdate = function handleUpdate () {
          var this$1 = this;

      if (this.isOpen()) {
          this.close();
      }
      this.selectedValue = this.$native.val();
      var itemsData = [];
      this.$items = $();
      // 生成 HTML
      this.$native.find('option').each(function (index, option) {
          var text = option.textContent || '';
          var value = option.value;
          var disabled = option.disabled;
          var selected = this$1.selectedValue === value;
          itemsData.push({
              value: value,
              text: text,
              disabled: disabled,
              selected: selected,
              index: index,
          });
          if (selected) {
              this$1.selectedText = text;
              this$1.selectedIndex = index;
          }
          this$1.$items = this$1.$items.add('<div class="mdui-select-menu-item mdui-ripple"' +
              (disabled ? ' disabled' : '') +
              (selected ? ' selected' : '') +
              ">" + text + "</div>");
      });
      this.$selected = $(("<span class=\"mdui-select-selected\">" + (this.selectedText) + "</span>"));
      this.$element = $("<div class=\"mdui-select mdui-select-position-" + (this.options.position) + "\" " +
          "style=\"" + (this.$native.attr('style')) + "\" " +
          "id=\"" + (this.uniqueID) + "\"></div>")
          .show()
          .append(this.$selected);
      this.$menu = $('<div class="mdui-select-menu"></div>')
          .appendTo(this.$element)
          .append(this.$items);
      $(("#" + (this.uniqueID))).remove();
      this.$native.after(this.$element);
      // 根据 select 的 size 属性设置高度
      this.size = parseInt(this.$native.attr('size') || '0');
      if (this.size <= 0) {
          this.size = this.$items.length;
          if (this.size > 8) {
              this.size = 8;
          }
      }
      // 点击选项时关闭下拉菜单
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      this.$items.on('click', function () {
          if (that.state === 'closing') {
              return;
          }
          var $item = $(this);
          var index = $item.index();
          var data = itemsData[index];
          if (data.disabled) {
              return;
          }
          that.$selected.text(data.text);
          that.$native.val(data.value);
          that.$items.removeAttr('selected');
          $item.attr('selected', '');
          that.selectedIndex = data.index;
          that.selectedValue = data.value;
          that.selectedText = data.text;
          that.$native.trigger('change');
          that.close();
      });
      // 点击 $element 时打开下拉菜单
      this.$element.on('click', function (event) {
          var $target = $(event.target);
          // 在菜单上点击时不打开
          if ($target.is('.mdui-select-menu') ||
              $target.is('.mdui-select-menu-item')) {
              return;
          }
          this$1.toggle();
      });
  };
  /**
   * 动画结束的回调
   */
  Select.prototype.transitionEnd = function transitionEnd () {
      this.$element.removeClass('mdui-select-closing');
      if (this.state === 'opening') {
          this.state = 'opened';
          this.triggerEvent('opened');
          this.$menu.css('overflow-y', 'auto');
      }
      if (this.state === 'closing') {
          this.state = 'closed';
          this.triggerEvent('closed');
          // 恢复样式
          this.$element.innerWidth('');
          this.$menu.css({
              'margin-top': '',
              height: '',
              width: '',
          });
      }
  };
  /**
   * 触发组件事件
   * @param name
   */
  Select.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'select', this.$native, this);
  };
  /**
   * 切换下拉菜单的打开状态
   */
  Select.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 打开下拉菜单
   */
  Select.prototype.open = function open () {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      this.state = 'opening';
      this.triggerEvent('open');
      this.readjustMenu();
      this.$element.addClass('mdui-select-open');
      this.$menu.transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 关闭下拉菜单
   */
  Select.prototype.close = function close () {
          var this$1 = this;

      if (!this.isOpen()) {
          return;
      }
      this.state = 'closing';
      this.triggerEvent('close');
      this.$menu.css('overflow-y', '');
      this.$element
          .removeClass('mdui-select-open')
          .addClass('mdui-select-closing');
      this.$menu.transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 获取当前菜单的状态。共包含四种状态：`opening`、`opened`、`closing`、`closed`
   */
  Select.prototype.getState = function getState () {
      return this.state;
  };
  mdui.Select = Select;

  var customAttr$4 = 'mdui-select';
  $(function () {
      mdui.mutation(("[" + customAttr$4 + "]"), function () {
          new mdui.Select(this, parseOptions(this, customAttr$4));
      });
  });

  $(function () {
      // 滚动时隐藏应用栏
      mdui.mutation('.mdui-appbar-scroll-hide', function () {
          new mdui.Headroom(this);
      });
      // 滚动时只隐藏应用栏中的工具栏
      mdui.mutation('.mdui-appbar-scroll-toolbar-hide', function () {
          new mdui.Headroom(this, {
              pinnedClass: 'mdui-headroom-pinned-toolbar',
              unpinnedClass: 'mdui-headroom-unpinned-toolbar',
          });
      });
  });

  var DEFAULT_OPTIONS$4 = {
      trigger: 'click',
      loop: false,
  };
  var Tab = function Tab(selector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$4);
      /**
       * 当前激活的 tab 的索引号。为 -1 时表示没有激活的选项卡，或不存在选项卡
       */
      this.activeIndex = -1;
      this.$element = $(selector).first();
      extend(this.options, options);
      this.$tabs = this.$element.children('a');
      this.$indicator = $('<div class="mdui-tab-indicator"></div>').appendTo(this.$element);
      // 根据 url hash 获取默认激活的选项卡
      var hash = window.location.hash;
      if (hash) {
          this.$tabs.each(function (index, tab) {
              if ($(tab).attr('href') === hash) {
                  this$1.activeIndex = index;
                  return false;
              }
              return true;
          });
      }
      // 含 .mdui-tab-active 的元素默认激活
      if (this.activeIndex === -1) {
          this.$tabs.each(function (index, tab) {
              if ($(tab).hasClass('mdui-tab-active')) {
                  this$1.activeIndex = index;
                  return false;
              }
              return true;
          });
      }
      // 存在选项卡时，默认激活第一个选项卡
      if (this.$tabs.length && this.activeIndex === -1) {
          this.activeIndex = 0;
      }
      // 设置激活状态选项卡
      this.setActive();
      // 监听窗口大小变化事件，调整指示器位置
      $window.on('resize', $.throttle(function () { return this$1.setIndicatorPosition(); }, 100));
      // 监听点击选项卡事件
      this.$tabs.each(function (_, tab) {
          this$1.bindTabEvent(tab);
      });
  };
  /**
   * 指定选项卡是否已禁用
   * @param $tab
   */
  Tab.prototype.isDisabled = function isDisabled ($tab) {
      return $tab.attr('disabled') !== undefined;
  };
  /**
   * 绑定在 Tab 上点击或悬浮的事件
   * @param tab
   */
  Tab.prototype.bindTabEvent = function bindTabEvent (tab) {
          var this$1 = this;

      var $tab = $(tab);
      // 点击或鼠标移入触发的事件
      var clickEvent = function () {
          // 禁用状态的选项卡无法选中
          if (this$1.isDisabled($tab)) {
              return false;
          }
          this$1.activeIndex = this$1.$tabs.index(tab);
          this$1.setActive();
      };
      // 无论 trigger 是 click 还是 hover，都会响应 click 事件
      $tab.on('click', clickEvent);
      // trigger 为 hover 时，额外响应 mouseenter 事件
      if (this.options.trigger === 'hover') {
          $tab.on('mouseenter', clickEvent);
      }
      // 阻止链接的默认点击动作
      $tab.on('click', function () {
          if (($tab.attr('href') || '').indexOf('#') === 0) {
              return false;
          }
      });
  };
  /**
   * 触发组件事件
   * @param name
   * @param $element
   * @param parameters
   */
  Tab.prototype.triggerEvent = function triggerEvent (name, $element, parameters) {
          if ( parameters === void 0 ) parameters = {};

      componentEvent(name, 'tab', $element, this, parameters);
  };
  /**
   * 设置激活状态的选项卡
   */
  Tab.prototype.setActive = function setActive () {
          var this$1 = this;

      this.$tabs.each(function (index, tab) {
          var $tab = $(tab);
          var targetId = $tab.attr('href') || '';
          // 设置选项卡激活状态
          if (index === this$1.activeIndex && !this$1.isDisabled($tab)) {
              if (!$tab.hasClass('mdui-tab-active')) {
                  this$1.triggerEvent('change', this$1.$element, {
                      index: this$1.activeIndex,
                      id: targetId.substr(1),
                  });
                  this$1.triggerEvent('show', $tab);
                  $tab.addClass('mdui-tab-active');
              }
              $(targetId).show();
              this$1.setIndicatorPosition();
          }
          else {
              $tab.removeClass('mdui-tab-active');
              $(targetId).hide();
          }
      });
  };
  /**
   * 设置选项卡指示器的位置
   */
  Tab.prototype.setIndicatorPosition = function setIndicatorPosition () {
      // 选项卡数量为 0 时，不显示指示器
      if (this.activeIndex === -1) {
          this.$indicator.css({
              left: 0,
              width: 0,
          });
          return;
      }
      var $activeTab = this.$tabs.eq(this.activeIndex);
      if (this.isDisabled($activeTab)) {
          return;
      }
      var activeTabOffset = $activeTab.offset();
      this.$indicator.css({
          left: ((activeTabOffset.left +
              this.$element[0].scrollLeft -
              this.$element[0].getBoundingClientRect().left) + "px"),
          width: (($activeTab.innerWidth()) + "px"),
      });
  };
  /**
   * 切换到下一个选项卡
   */
  Tab.prototype.next = function next () {
      if (this.activeIndex === -1) {
          return;
      }
      if (this.$tabs.length > this.activeIndex + 1) {
          this.activeIndex++;
      }
      else if (this.options.loop) {
          this.activeIndex = 0;
      }
      this.setActive();
  };
  /**
   * 切换到上一个选项卡
   */
  Tab.prototype.prev = function prev () {
      if (this.activeIndex === -1) {
          return;
      }
      if (this.activeIndex > 0) {
          this.activeIndex--;
      }
      else if (this.options.loop) {
          this.activeIndex = this.$tabs.length - 1;
      }
      this.setActive();
  };
  /**
   * 显示指定索引号、或指定id的选项卡
   * @param index 索引号、或id
   */
  Tab.prototype.show = function show (index) {
          var this$1 = this;

      if (this.activeIndex === -1) {
          return;
      }
      if (isNumber(index)) {
          this.activeIndex = index;
      }
      else {
          this.$tabs.each(function (i, tab) {
              if (tab.id === index) {
                  this$1.activeIndex = i;
                  return false;
              }
          });
      }
      this.setActive();
  };
  /**
   * 在父元素的宽度变化时，需要调用该方法重新调整指示器位置
   * 在添加或删除选项卡时，需要调用该方法
   */
  Tab.prototype.handleUpdate = function handleUpdate () {
          var this$1 = this;

      var $oldTabs = this.$tabs; // 旧的 tabs JQ对象
      var $newTabs = this.$element.children('a'); // 新的 tabs JQ对象
      var oldTabsElement = $oldTabs.get(); // 旧的 tabs 元素数组
      var newTabsElement = $newTabs.get(); // 新的 tabs 元素数组
      if (!$newTabs.length) {
          this.activeIndex = -1;
          this.$tabs = $newTabs;
          this.setIndicatorPosition();
          return;
      }
      // 重新遍历选项卡，找出新增的选项卡
      $newTabs.each(function (index, tab) {
          // 有新增的选项卡
          if (oldTabsElement.indexOf(tab) < 0) {
              this$1.bindTabEvent(tab);
              if (this$1.activeIndex === -1) {
                  this$1.activeIndex = 0;
              }
              else if (index <= this$1.activeIndex) {
                  this$1.activeIndex++;
              }
          }
      });
      // 找出被移除的选项卡
      $oldTabs.each(function (index, tab) {
          // 有被移除的选项卡
          if (newTabsElement.indexOf(tab) < 0) {
              if (index < this$1.activeIndex) {
                  this$1.activeIndex--;
              }
              else if (index === this$1.activeIndex) {
                  this$1.activeIndex = 0;
              }
          }
      });
      this.$tabs = $newTabs;
      this.setActive();
  };
  mdui.Tab = Tab;

  var customAttr$5 = 'mdui-tab';
  $(function () {
      mdui.mutation(("[" + customAttr$5 + "]"), function () {
          new mdui.Tab(this, parseOptions(this, customAttr$5));
      });
  });

  /**
   * 在桌面设备上默认显示抽屉栏，不显示遮罩层
   * 在手机和平板设备上默认不显示抽屉栏，始终显示遮罩层，且覆盖导航栏
   */
  var DEFAULT_OPTIONS$5 = {
      overlay: false,
      swipe: false,
  };
  var Drawer = function Drawer(selector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$5);
      /**
       * 当前是否显示着遮罩层
       */
      this.overlay = false;
      this.$element = $(selector).first();
      extend(this.options, options);
      this.position = this.$element.hasClass('mdui-drawer-right')
          ? 'right'
          : 'left';
      if (this.$element.hasClass('mdui-drawer-close')) {
          this.state = 'closed';
      }
      else if (this.$element.hasClass('mdui-drawer-open')) {
          this.state = 'opened';
      }
      else if (this.isDesktop()) {
          this.state = 'opened';
      }
      else {
          this.state = 'closed';
      }
      // 浏览器窗口大小调整时
      $window.on('resize', $.throttle(function () {
          if (this$1.isDesktop()) {
              // 由手机平板切换到桌面时
              // 如果显示着遮罩，则隐藏遮罩
              if (this$1.overlay && !this$1.options.overlay) {
                  $.hideOverlay();
                  this$1.overlay = false;
                  $.unlockScreen();
              }
              // 没有强制关闭，则状态为打开状态
              if (!this$1.$element.hasClass('mdui-drawer-close')) {
                  this$1.state = 'opened';
              }
          }
          else if (!this$1.overlay && this$1.state === 'opened') {
              // 由桌面切换到手机平板时。如果抽屉栏是打开着的且没有遮罩层，则关闭抽屉栏
              if (this$1.$element.hasClass('mdui-drawer-open')) {
                  $.showOverlay();
                  this$1.overlay = true;
                  $.lockScreen();
                  $('.mdui-overlay').one('click', function () { return this$1.close(); });
              }
              else {
                  this$1.state = 'closed';
              }
          }
      }, 100));
      // 绑定关闭按钮事件
      this.$element.find('[mdui-drawer-close]').each(function (_, close) {
          $(close).on('click', function () { return this$1.close(); });
      });
      this.swipeSupport();
  };
  /**
   * 是否是桌面设备
   */
  Drawer.prototype.isDesktop = function isDesktop () {
      return $window.width() >= 1024;
  };
  /**
   * 滑动手势支持
   */
  Drawer.prototype.swipeSupport = function swipeSupport () {
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      // 抽屉栏滑动手势控制
      var openNavEventHandler;
      var touchStartX;
      var touchStartY;
      var swipeStartX;
      var swiping = null;
      var maybeSwiping = false;
      var $body = $('body');
      // 手势触发的范围
      var swipeAreaWidth = 24;
      function setPosition(translateX) {
          var rtlTranslateMultiplier = that.position === 'right' ? -1 : 1;
          var transformCSS = "translate(" + (-1 * rtlTranslateMultiplier * translateX) + "px, 0) !important;";
          var transitionCSS = 'initial !important;';
          that.$element.css('cssText', ("transform: " + transformCSS + "; transition: " + transitionCSS + ";"));
      }
      function cleanPosition() {
          that.$element[0].style.transform = '';
          that.$element[0].style.webkitTransform = '';
          that.$element[0].style.transition = '';
          that.$element[0].style.webkitTransition = '';
      }
      function getMaxTranslateX() {
          return that.$element.width() + 10;
      }
      function getTranslateX(currentX) {
          return Math.min(Math.max(swiping === 'closing'
              ? swipeStartX - currentX
              : getMaxTranslateX() + swipeStartX - currentX, 0), getMaxTranslateX());
      }
      function onBodyTouchEnd(event) {
          if (swiping) {
              var touchX = event.changedTouches[0].pageX;
              if (that.position === 'right') {
                  touchX = $body.width() - touchX;
              }
              var translateRatio = getTranslateX(touchX) / getMaxTranslateX();
              maybeSwiping = false;
              var swipingState = swiping;
              swiping = null;
              if (swipingState === 'opening') {
                  if (translateRatio < 0.92) {
                      cleanPosition();
                      that.open();
                  }
                  else {
                      cleanPosition();
                  }
              }
              else {
                  if (translateRatio > 0.08) {
                      cleanPosition();
                      that.close();
                  }
                  else {
                      cleanPosition();
                  }
              }
              $.unlockScreen();
          }
          else {
              maybeSwiping = false;
          }
          $body.off({
              // eslint-disable-next-line @typescript-eslint/no-use-before-define
              touchmove: onBodyTouchMove,
              touchend: onBodyTouchEnd,
              // eslint-disable-next-line @typescript-eslint/no-use-before-define
              touchcancel: onBodyTouchMove,
          });
      }
      function onBodyTouchMove(event) {
          var touchX = event.touches[0].pageX;
          if (that.position === 'right') {
              touchX = $body.width() - touchX;
          }
          var touchY = event.touches[0].pageY;
          if (swiping) {
              setPosition(getTranslateX(touchX));
          }
          else if (maybeSwiping) {
              var dXAbs = Math.abs(touchX - touchStartX);
              var dYAbs = Math.abs(touchY - touchStartY);
              var threshold = 8;
              if (dXAbs > threshold && dYAbs <= threshold) {
                  swipeStartX = touchX;
                  swiping = that.state === 'opened' ? 'closing' : 'opening';
                  $.lockScreen();
                  setPosition(getTranslateX(touchX));
              }
              else if (dXAbs <= threshold && dYAbs > threshold) {
                  onBodyTouchEnd();
              }
          }
      }
      function onBodyTouchStart(event) {
          touchStartX = event.touches[0].pageX;
          if (that.position === 'right') {
              touchStartX = $body.width() - touchStartX;
          }
          touchStartY = event.touches[0].pageY;
          if (that.state !== 'opened') {
              if (touchStartX > swipeAreaWidth ||
                  openNavEventHandler !== onBodyTouchStart) {
                  return;
              }
          }
          maybeSwiping = true;
          $body.on({
              touchmove: onBodyTouchMove,
              touchend: onBodyTouchEnd,
              touchcancel: onBodyTouchMove,
          });
      }
      function enableSwipeHandling() {
          if (!openNavEventHandler) {
              $body.on('touchstart', onBodyTouchStart);
              openNavEventHandler = onBodyTouchStart;
          }
      }
      if (this.options.swipe) {
          enableSwipeHandling();
      }
  };
  /**
   * 触发组件事件
   * @param name
   */
  Drawer.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'drawer', this.$element, this);
  };
  /**
   * 动画结束回调
   */
  Drawer.prototype.transitionEnd = function transitionEnd () {
      if (this.$element.hasClass('mdui-drawer-open')) {
          this.state = 'opened';
          this.triggerEvent('opened');
      }
      else {
          this.state = 'closed';
          this.triggerEvent('closed');
      }
  };
  /**
   * 是否处于打开状态
   */
  Drawer.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 打开抽屉栏
   */
  Drawer.prototype.open = function open () {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      this.state = 'opening';
      this.triggerEvent('open');
      if (!this.options.overlay) {
          $('body').addClass(("mdui-drawer-body-" + (this.position)));
      }
      this.$element
          .removeClass('mdui-drawer-close')
          .addClass('mdui-drawer-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
      if (!this.isDesktop() || this.options.overlay) {
          this.overlay = true;
          $.showOverlay().one('click', function () { return this$1.close(); });
          $.lockScreen();
      }
  };
  /**
   * 关闭抽屉栏
   */
  Drawer.prototype.close = function close () {
          var this$1 = this;

      if (!this.isOpen()) {
          return;
      }
      this.state = 'closing';
      this.triggerEvent('close');
      if (!this.options.overlay) {
          $('body').removeClass(("mdui-drawer-body-" + (this.position)));
      }
      this.$element
          .addClass('mdui-drawer-close')
          .removeClass('mdui-drawer-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
      if (this.overlay) {
          $.hideOverlay();
          this.overlay = false;
          $.unlockScreen();
      }
  };
  /**
   * 切换抽屉栏打开/关闭状态
   */
  Drawer.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 返回当前抽屉栏的状态。共包含四种状态：`opening`、`opened`、`closing`、`closed`
   */
  Drawer.prototype.getState = function getState () {
      return this.state;
  };
  mdui.Drawer = Drawer;

  var customAttr$6 = 'mdui-drawer';
  $(function () {
      mdui.mutation(("[" + customAttr$6 + "]"), function () {
          var $element = $(this);
          var options = parseOptions(this, customAttr$6);
          var selector = options.target;
          // @ts-ignore
          delete options.target;
          var $drawer = $(selector).first();
          var instance = new mdui.Drawer($drawer, options);
          $element.on('click', function () { return instance.toggle(); });
      });
  });

  var container = {};
  function queue(name, func) {
      if (isUndefined(container[name])) {
          container[name] = [];
      }
      if (isUndefined(func)) {
          return container[name];
      }
      container[name].push(func);
  }
  /**
   * 从队列中移除第一个函数，并执行该函数
   * @param name 队列满
   */
  function dequeue(name) {
      if (isUndefined(container[name])) {
          return;
      }
      if (!container[name].length) {
          return;
      }
      var func = container[name].shift();
      func();
  }

  var DEFAULT_OPTIONS$6 = {
      history: true,
      overlay: true,
      modal: false,
      closeOnEsc: true,
      closeOnCancel: true,
      closeOnConfirm: true,
      destroyOnClosed: false,
  };
  /**
   * 当前显示的对话框实例
   */
  var currentInst = null;
  /**
   * 队列名
   */
  var queueName = '_mdui_dialog';
  /**
   * 窗口是否已锁定
   */
  var isLockScreen = false;
  /**
   * 遮罩层元素
   */
  var $overlay;
  var Dialog = function Dialog(selector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$6);
      /**
       * 当前 dialog 的状态
       */
      this.state = 'closed';
      /**
       * dialog 元素是否是动态添加的
       */
      this.append = false;
      this.$element = $(selector).first();
      // 如果对话框元素没有在当前文档中，则需要添加
      if (!contains(document.body, this.$element[0])) {
          this.append = true;
          $('body').append(this.$element);
      }
      extend(this.options, options);
      // 绑定取消按钮事件
      this.$element.find('[mdui-dialog-cancel]').each(function (_, cancel) {
          $(cancel).on('click', function () {
              this$1.triggerEvent('cancel');
              if (this$1.options.closeOnCancel) {
                  this$1.close();
              }
          });
      });
      // 绑定确认按钮事件
      this.$element.find('[mdui-dialog-confirm]').each(function (_, confirm) {
          $(confirm).on('click', function () {
              this$1.triggerEvent('confirm');
              if (this$1.options.closeOnConfirm) {
                  this$1.close();
              }
          });
      });
      // 绑定关闭按钮事件
      this.$element.find('[mdui-dialog-close]').each(function (_, close) {
          $(close).on('click', function () { return this$1.close(); });
      });
  };
  /**
   * 触发组件事件
   * @param name
   */
  Dialog.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'dialog', this.$element, this);
  };
  /**
   * 窗口宽度变化，或对话框内容变化时，调整对话框位置和对话框内的滚动条
   */
  Dialog.prototype.readjust = function readjust () {
      if (!currentInst) {
          return;
      }
      var $element = currentInst.$element;
      var $title = $element.children('.mdui-dialog-title');
      var $content = $element.children('.mdui-dialog-content');
      var $actions = $element.children('.mdui-dialog-actions');
      // 调整 dialog 的 top 和 height 值
      $element.height('');
      $content.height('');
      var elementHeight = $element.height();
      $element.css({
          top: ((($window.height() - elementHeight) / 2) + "px"),
          height: (elementHeight + "px"),
      });
      // 调整 mdui-dialog-content 的高度
      $content.innerHeight(elementHeight -
          ($title.innerHeight() || 0) -
          ($actions.innerHeight() || 0));
  };
  /**
   * hashchange 事件触发时关闭对话框
   */
  Dialog.prototype.hashchangeEvent = function hashchangeEvent () {
      if (window.location.hash.substring(1).indexOf('mdui-dialog') < 0) {
          currentInst.close(true);
      }
  };
  /**
   * 点击遮罩层关闭对话框
   * @param event
   */
  Dialog.prototype.overlayClick = function overlayClick (event) {
      if ($(event.target).hasClass('mdui-overlay') &&
          currentInst) {
          currentInst.close();
      }
  };
  /**
   * 动画结束回调
   */
  Dialog.prototype.transitionEnd = function transitionEnd () {
      if (this.$element.hasClass('mdui-dialog-open')) {
          this.state = 'opened';
          this.triggerEvent('opened');
      }
      else {
          this.state = 'closed';
          this.triggerEvent('closed');
          this.$element.hide();
          // 所有对话框都关闭，且当前没有打开的对话框时，解锁屏幕
          if (!queue(queueName).length && !currentInst && isLockScreen) {
              $.unlockScreen();
              isLockScreen = false;
          }
          $window.off('resize', $.throttle(this.readjust, 100));
          if (this.options.destroyOnClosed) {
              this.destroy();
          }
      }
  };
  /**
   * 打开指定对话框
   */
  Dialog.prototype.doOpen = function doOpen () {
          var this$1 = this;

      currentInst = this;
      if (!isLockScreen) {
          $.lockScreen();
          isLockScreen = true;
      }
      this.$element.show();
      this.readjust();
      $window.on('resize', $.throttle(this.readjust, 100));
      // 打开消息框
      this.state = 'opening';
      this.triggerEvent('open');
      this.$element
          .addClass('mdui-dialog-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
      // 不存在遮罩层元素时，添加遮罩层
      if (!$overlay) {
          $overlay = $.showOverlay(5100);
      }
      // 点击遮罩层时是否关闭对话框
      if (this.options.modal) {
          $overlay.off('click', this.overlayClick);
      }
      else {
          $overlay.on('click', this.overlayClick);
      }
      // 是否显示遮罩层，不显示时，把遮罩层背景透明
      $overlay.css('opacity', this.options.overlay ? '' : 0);
      if (this.options.history) {
          // 如果 hash 中原来就有 mdui-dialog，先删除，避免后退历史纪录后仍然有 mdui-dialog 导致无法关闭
          // 包括 mdui-dialog 和 &mdui-dialog 和 ?mdui-dialog
          var hash = window.location.hash.substring(1);
          if (hash.indexOf('mdui-dialog') > -1) {
              hash = hash.replace(/[&?]?mdui-dialog/g, '');
          }
          // 后退按钮关闭对话框
          if (hash) {
              window.location.hash = "" + hash + (hash.indexOf('?') > -1 ? '&' : '?') + "mdui-dialog";
          }
          else {
              window.location.hash = 'mdui-dialog';
          }
          $window.on('hashchange', this.hashchangeEvent);
      }
  };
  /**
   * 当前对话框是否为打开状态
   */
  Dialog.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 打开对话框
   */
  Dialog.prototype.open = function open () {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      // 如果当前有正在打开或已经打开的对话框,或队列不为空，则先加入队列，等旧对话框开始关闭时再打开
      if ((currentInst &&
          (currentInst.state === 'opening' || currentInst.state === 'opened')) ||
          queue(queueName).length) {
          queue(queueName, function () { return this$1.doOpen(); });
          return;
      }
      this.doOpen();
  };
  /**
   * 关闭对话框
   */
  Dialog.prototype.close = function close (historyBack) {
          var this$1 = this;
          if ( historyBack === void 0 ) historyBack = false;

      // historyBack 是否需要后退历史纪录，默认为 `false`。该参数仅内部使用
      // 为 `false` 时是通过 js 关闭，需要后退一个历史记录
      // 为 `true` 时是通过后退按钮关闭，不需要后退历史记录
      // setTimeout 的作用是：
      // 当同时关闭一个对话框，并打开另一个对话框时，使打开对话框的操作先执行，以使需要打开的对话框先加入队列
      setTimeout(function () {
          if (!this$1.isOpen()) {
              return;
          }
          currentInst = null;
          this$1.state = 'closing';
          this$1.triggerEvent('close');
          // 所有对话框都关闭，且当前没有打开的对话框时，隐藏遮罩
          if (!queue(queueName).length && $overlay) {
              $.hideOverlay();
              $overlay = null;
              // 若仍存在遮罩，恢复遮罩的 z-index
              $('.mdui-overlay').css('z-index', 2000);
          }
          this$1.$element
              .removeClass('mdui-dialog-open')
              .transitionEnd(function () { return this$1.transitionEnd(); });
          if (this$1.options.history && !queue(queueName).length) {
              if (!historyBack) {
                  window.history.back();
              }
              $window.off('hashchange', this$1.hashchangeEvent);
          }
          // 关闭旧对话框，打开新对话框。
          // 加一点延迟，仅仅为了视觉效果更好。不加延时也不影响功能
          setTimeout(function () {
              dequeue(queueName);
          }, 100);
      });
  };
  /**
   * 切换对话框打开/关闭状态
   */
  Dialog.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 获取对话框状态。共包含四种状态：`opening`、`opened`、`closing`、`closed`
   */
  Dialog.prototype.getState = function getState () {
      return this.state;
  };
  /**
   * 销毁对话框
   */
  Dialog.prototype.destroy = function destroy () {
      if (this.append) {
          this.$element.remove();
      }
      if (!queue(queueName).length && !currentInst) {
          if ($overlay) {
              $.hideOverlay();
              $overlay = null;
          }
          if (isLockScreen) {
              $.unlockScreen();
              isLockScreen = false;
          }
      }
  };
  /**
   * 对话框内容变化时，需要调用该方法来调整对话框位置和滚动条高度
   */
  Dialog.prototype.handleUpdate = function handleUpdate () {
      this.readjust();
  };

  // esc 按下时关闭对话框
  $document.on('keydown', function (event) {
      if (currentInst &&
          currentInst.options.closeOnEsc &&
          currentInst.state === 'opened' &&
          event.keyCode === 27) {
          currentInst.close();
      }
  });
  mdui.Dialog = Dialog;

  var customAttr$7 = 'mdui-dialog';
  var dataName$1 = '_mdui_dialog';
  $(function () {
      $document.on('click', ("[" + customAttr$7 + "]"), function () {
          var options = parseOptions(this, customAttr$7);
          var selector = options.target;
          // @ts-ignore
          delete options.target;
          var $dialog = $(selector).first();
          var instance = $dialog.data(dataName$1);
          if (!instance) {
              instance = new mdui.Dialog($dialog, options);
              $dialog.data(dataName$1, instance);
          }
          instance.open();
      });
  });

  var DEFAULT_BUTTON = {
      text: '',
      bold: false,
      close: true,
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClick: function () { },
  };
  var DEFAULT_OPTIONS$7 = {
      title: '',
      content: '',
      buttons: [],
      stackedButtons: false,
      cssClass: '',
      history: true,
      overlay: true,
      modal: false,
      closeOnEsc: true,
      destroyOnClosed: true,
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onOpen: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onOpened: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClose: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClosed: function () { },
  };
  mdui.dialog = function (options) {
      var _a, _b;
      // 合并配置参数
      options = extend({}, DEFAULT_OPTIONS$7, options);
      each(options.buttons, function (i, button) {
          options.buttons[i] = extend({}, DEFAULT_BUTTON, button);
      });
      // 按钮的 HTML
      var buttonsHTML = '';
      if ((_a = options.buttons) === null || _a === void 0 ? void 0 : _a.length) {
          buttonsHTML = "<div class=\"mdui-dialog-actions" + (options.stackedButtons ? ' mdui-dialog-actions-stacked' : '') + "\">";
          each(options.buttons, function (_, button) {
              buttonsHTML +=
                  '<a href="javascript:void(0)" ' +
                      "class=\"mdui-btn mdui-ripple mdui-text-color-primary " + (button.bold ? 'mdui-btn-bold' : '') + "\">" + (button.text) + "</a>";
          });
          buttonsHTML += '</div>';
      }
      // Dialog 的 HTML
      var HTML = "<div class=\"mdui-dialog " + (options.cssClass) + "\">" +
          (options.title
              ? ("<div class=\"mdui-dialog-title\">" + (options.title) + "</div>")
              : '') +
          (options.content
              ? ("<div class=\"mdui-dialog-content\">" + (options.content) + "</div>")
              : '') +
          buttonsHTML +
          '</div>';
      // 实例化 Dialog
      var instance = new mdui.Dialog(HTML, {
          history: options.history,
          overlay: options.overlay,
          modal: options.modal,
          closeOnEsc: options.closeOnEsc,
          destroyOnClosed: options.destroyOnClosed,
      });
      // 绑定按钮事件
      if ((_b = options.buttons) === null || _b === void 0 ? void 0 : _b.length) {
          instance.$element
              .find('.mdui-dialog-actions .mdui-btn')
              .each(function (index, button) {
              $(button).on('click', function () {
                  options.buttons[index].onClick(instance);
                  if (options.buttons[index].close) {
                      instance.close();
                  }
              });
          });
      }
      // 绑定打开关闭事件
      instance.$element
          .on('open.mdui.dialog', function () {
          options.onOpen(instance);
      })
          .on('opened.mdui.dialog', function () {
          options.onOpened(instance);
      })
          .on('close.mdui.dialog', function () {
          options.onClose(instance);
      })
          .on('closed.mdui.dialog', function () {
          options.onClosed(instance);
      });
      instance.open();
      return instance;
  };

  var DEFAULT_OPTIONS$8 = {
      confirmText: 'ok',
      history: true,
      modal: false,
      closeOnEsc: true,
      closeOnConfirm: true,
  };
  mdui.alert = function (text, title, onConfirm, options) {
      if (isFunction(title)) {
          options = onConfirm;
          onConfirm = title;
          title = '';
      }
      if (isUndefined(onConfirm)) {
          // eslint-disable-next-line @typescript-eslint/no-empty-function
          onConfirm = function () { };
      }
      if (isUndefined(options)) {
          options = {};
      }
      options = extend({}, DEFAULT_OPTIONS$8, options);
      return mdui.dialog({
          title: title,
          content: text,
          buttons: [
              {
                  text: options.confirmText,
                  bold: false,
                  close: options.closeOnConfirm,
                  onClick: onConfirm,
              } ],
          cssClass: 'mdui-dialog-alert',
          history: options.history,
          modal: options.modal,
          closeOnEsc: options.closeOnEsc,
      });
  };

  var DEFAULT_OPTIONS$9 = {
      confirmText: 'ok',
      cancelText: 'cancel',
      history: true,
      modal: false,
      closeOnEsc: true,
      closeOnCancel: true,
      closeOnConfirm: true,
  };
  mdui.confirm = function (text, title, onConfirm, onCancel, options) {
      if (isFunction(title)) {
          options = onCancel;
          onCancel = onConfirm;
          onConfirm = title;
          title = '';
      }
      if (isUndefined(onConfirm)) {
          // eslint-disable-next-line @typescript-eslint/no-empty-function
          onConfirm = function () { };
      }
      if (isUndefined(onCancel)) {
          // eslint-disable-next-line @typescript-eslint/no-empty-function
          onCancel = function () { };
      }
      if (isUndefined(options)) {
          options = {};
      }
      options = extend({}, DEFAULT_OPTIONS$9, options);
      return mdui.dialog({
          title: title,
          content: text,
          buttons: [
              {
                  text: options.cancelText,
                  bold: false,
                  close: options.closeOnCancel,
                  onClick: onCancel,
              },
              {
                  text: options.confirmText,
                  bold: false,
                  close: options.closeOnConfirm,
                  onClick: onConfirm,
              } ],
          cssClass: 'mdui-dialog-confirm',
          history: options.history,
          modal: options.modal,
          closeOnEsc: options.closeOnEsc,
      });
  };

  var DEFAULT_OPTIONS$a = {
      confirmText: 'ok',
      cancelText: 'cancel',
      history: true,
      modal: false,
      closeOnEsc: true,
      closeOnCancel: true,
      closeOnConfirm: true,
      type: 'text',
      maxlength: 0,
      defaultValue: '',
      confirmOnEnter: false,
  };
  mdui.prompt = function (label, title, onConfirm, onCancel, options) {
      if (isFunction(title)) {
          options = onCancel;
          onCancel = onConfirm;
          onConfirm = title;
          title = '';
      }
      if (isUndefined(onConfirm)) {
          // eslint-disable-next-line @typescript-eslint/no-empty-function
          onConfirm = function () { };
      }
      if (isUndefined(onCancel)) {
          // eslint-disable-next-line @typescript-eslint/no-empty-function
          onCancel = function () { };
      }
      if (isUndefined(options)) {
          options = {};
      }
      options = extend({}, DEFAULT_OPTIONS$a, options);
      var content = '<div class="mdui-textfield">' +
          (label ? ("<label class=\"mdui-textfield-label\">" + label + "</label>") : '') +
          (options.type === 'text'
              ? ("<input class=\"mdui-textfield-input\" type=\"text\" value=\"" + (options.defaultValue) + "\" " + (options.maxlength ? 'maxlength="' + options.maxlength + '"' : '') + "/>")
              : '') +
          (options.type === 'textarea'
              ? ("<textarea class=\"mdui-textfield-input\" " + (options.maxlength ? 'maxlength="' + options.maxlength + '"' : '') + ">" + (options.defaultValue) + "</textarea>")
              : '') +
          '</div>';
      var onCancelClick = function (dialog) {
          var value = dialog.$element.find('.mdui-textfield-input').val();
          onCancel(value, dialog);
      };
      var onConfirmClick = function (dialog) {
          var value = dialog.$element.find('.mdui-textfield-input').val();
          onConfirm(value, dialog);
      };
      return mdui.dialog({
          title: title,
          content: content,
          buttons: [
              {
                  text: options.cancelText,
                  bold: false,
                  close: options.closeOnCancel,
                  onClick: onCancelClick,
              },
              {
                  text: options.confirmText,
                  bold: false,
                  close: options.closeOnConfirm,
                  onClick: onConfirmClick,
              } ],
          cssClass: 'mdui-dialog-prompt',
          history: options.history,
          modal: options.modal,
          closeOnEsc: options.closeOnEsc,
          onOpen: function (dialog) {
              // 初始化输入框
              var $input = dialog.$element.find('.mdui-textfield-input');
              mdui.updateTextFields($input);
              // 聚焦到输入框
              $input[0].focus();
              // 捕捉文本框回车键，在单行文本框的情况下触发回调
              if (options.type !== 'textarea' && options.confirmOnEnter === true) {
                  $input.on('keydown', function (event) {
                      if (event.keyCode === 13) {
                          var value = dialog.$element.find('.mdui-textfield-input').val();
                          onConfirm(value, dialog);
                          if (options.closeOnConfirm) {
                              dialog.close();
                          }
                          return false;
                      }
                      return;
                  });
              }
              // 如果是多行输入框，监听输入框的 input 事件，更新对话框高度
              if (options.type === 'textarea') {
                  $input.on('input', function () { return dialog.handleUpdate(); });
              }
              // 有字符数限制时，加载完文本框后 DOM 会变化，需要更新对话框高度
              if (options.maxlength) {
                  dialog.handleUpdate();
              }
          },
      });
  };

  var DEFAULT_OPTIONS$b = {
      position: 'auto',
      delay: 0,
      content: '',
  };
  var Tooltip = function Tooltip(selector, options) {
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$b);
      /**
       * 当前 tooltip 的状态
       */
      this.state = 'closed';
      /**
       * setTimeout 的返回值
       */
      this.timeoutId = null;
      this.$target = $(selector).first();
      extend(this.options, options);
      // 创建 Tooltip HTML
      this.$element = $(("<div class=\"mdui-tooltip\" id=\"" + ($.guid()) + "\">" + (this.options.content) + "</div>")).appendTo(document.body);
      // 绑定事件。元素处于 disabled 状态时无法触发鼠标事件，为了统一，把 touch 事件也禁用
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      this.$target
          .on('touchstart mouseenter', function (event) {
          if (that.isDisabled(this)) {
              return;
          }
          if (!isAllow(event)) {
              return;
          }
          register(event);
          that.open();
      })
          .on('touchend mouseleave', function (event) {
          if (that.isDisabled(this)) {
              return;
          }
          if (!isAllow(event)) {
              return;
          }
          that.close();
      })
          .on(unlockEvent, function (event) {
          if (that.isDisabled(this)) {
              return;
          }
          register(event);
      });
  };
  /**
   * 元素是否已禁用
   * @param element
   */
  Tooltip.prototype.isDisabled = function isDisabled (element) {
      return (element.disabled ||
          $(element).attr('disabled') !== undefined);
  };
  /**
   * 是否是桌面设备
   */
  Tooltip.prototype.isDesktop = function isDesktop () {
      return $window.width() > 1024;
  };
  /**
   * 设置 Tooltip 的位置
   */
  Tooltip.prototype.setPosition = function setPosition () {
      var marginLeft;
      var marginTop;
      // 触发的元素
      var targetProps = this.$target[0].getBoundingClientRect();
      // 触发的元素和 Tooltip 之间的距离
      var targetMargin = this.isDesktop() ? 14 : 24;
      // Tooltip 的宽度和高度
      var tooltipWidth = this.$element[0].offsetWidth;
      var tooltipHeight = this.$element[0].offsetHeight;
      // Tooltip 的方向
      var position = this.options.position;
      // 自动判断位置，加 2px，使 Tooltip 距离窗口边框至少有 2px 的间距
      if (position === 'auto') {
          if (targetProps.top +
              targetProps.height +
              targetMargin +
              tooltipHeight +
              2 <
              $window.height()) {
              position = 'bottom';
          }
          else if (targetMargin + tooltipHeight + 2 < targetProps.top) {
              position = 'top';
          }
          else if (targetMargin + tooltipWidth + 2 < targetProps.left) {
              position = 'left';
          }
          else if (targetProps.width + targetMargin + tooltipWidth + 2 <
              $window.width() - targetProps.left) {
              position = 'right';
          }
          else {
              position = 'bottom';
          }
      }
      // 设置位置
      switch (position) {
          case 'bottom':
              marginLeft = -1 * (tooltipWidth / 2);
              marginTop = targetProps.height / 2 + targetMargin;
              this.$element.transformOrigin('top center');
              break;
          case 'top':
              marginLeft = -1 * (tooltipWidth / 2);
              marginTop =
                  -1 * (tooltipHeight + targetProps.height / 2 + targetMargin);
              this.$element.transformOrigin('bottom center');
              break;
          case 'left':
              marginLeft = -1 * (tooltipWidth + targetProps.width / 2 + targetMargin);
              marginTop = -1 * (tooltipHeight / 2);
              this.$element.transformOrigin('center right');
              break;
          case 'right':
              marginLeft = targetProps.width / 2 + targetMargin;
              marginTop = -1 * (tooltipHeight / 2);
              this.$element.transformOrigin('center left');
              break;
      }
      var targetOffset = this.$target.offset();
      this.$element.css({
          top: ((targetOffset.top + targetProps.height / 2) + "px"),
          left: ((targetOffset.left + targetProps.width / 2) + "px"),
          'margin-left': (marginLeft + "px"),
          'margin-top': (marginTop + "px"),
      });
  };
  /**
   * 触发组件事件
   * @param name
   */
  Tooltip.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'tooltip', this.$target, this);
  };
  /**
   * 动画结束回调
   */
  Tooltip.prototype.transitionEnd = function transitionEnd () {
      if (this.$element.hasClass('mdui-tooltip-open')) {
          this.state = 'opened';
          this.triggerEvent('opened');
      }
      else {
          this.state = 'closed';
          this.triggerEvent('closed');
      }
  };
  /**
   * 当前 tooltip 是否为打开状态
   */
  Tooltip.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 执行打开 tooltip
   */
  Tooltip.prototype.doOpen = function doOpen () {
          var this$1 = this;

      this.state = 'opening';
      this.triggerEvent('open');
      this.$element
          .addClass('mdui-tooltip-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 打开 Tooltip
   * @param options 允许每次打开时设置不同的参数
   */
  Tooltip.prototype.open = function open (options) {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      var oldOptions = extend({}, this.options);
      if (options) {
          extend(this.options, options);
      }
      // tooltip 的内容有更新
      if (oldOptions.content !== this.options.content) {
          this.$element.html(this.options.content);
      }
      this.setPosition();
      if (this.options.delay) {
          this.timeoutId = setTimeout(function () { return this$1.doOpen(); }, this.options.delay);
      }
      else {
          this.timeoutId = null;
          this.doOpen();
      }
  };
  /**
   * 关闭 Tooltip
   */
  Tooltip.prototype.close = function close () {
          var this$1 = this;

      if (this.timeoutId) {
          clearTimeout(this.timeoutId);
          this.timeoutId = null;
      }
      if (!this.isOpen()) {
          return;
      }
      this.state = 'closing';
      this.triggerEvent('close');
      this.$element
          .removeClass('mdui-tooltip-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 切换 Tooltip 的打开状态
   */
  Tooltip.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 获取 Tooltip 状态。共包含四种状态：`opening`、`opened`、`closing`、`closed`
   */
  Tooltip.prototype.getState = function getState () {
      return this.state;
  };
  mdui.Tooltip = Tooltip;

  var customAttr$8 = 'mdui-tooltip';
  var dataName$2 = '_mdui_tooltip';
  $(function () {
      // mouseenter 不能冒泡，所以这里用 mouseover 代替
      $document.on('touchstart mouseover', ("[" + customAttr$8 + "]"), function () {
          var $target = $(this);
          var instance = $target.data(dataName$2);
          if (!instance) {
              instance = new mdui.Tooltip(this, parseOptions(this, customAttr$8));
              $target.data(dataName$2, instance);
          }
      });
  });

  var DEFAULT_OPTIONS$c = {
      message: '',
      timeout: 4000,
      position: 'bottom',
      buttonText: '',
      buttonColor: '',
      closeOnButtonClick: true,
      closeOnOutsideClick: true,
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClick: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onButtonClick: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onOpen: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onOpened: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClose: function () { },
      // eslint-disable-next-line @typescript-eslint/no-empty-function
      onClosed: function () { },
  };
  /**
   * 当前打开着的 Snackbar
   */
  var currentInst$1 = null;
  /**
   * 队列名
   */
  var queueName$1 = '_mdui_snackbar';
  var Snackbar = function Snackbar(options) {
      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$c);
      /**
       * 当前 Snackbar 的状态
       */
      this.state = 'closed';
      /**
       * setTimeout 的 ID
       */
      this.timeoutId = null;
      extend(this.options, options);
      // 按钮颜色
      var buttonColorStyle = '';
      var buttonColorClass = '';
      if (this.options.buttonColor.indexOf('#') === 0 ||
          this.options.buttonColor.indexOf('rgb') === 0) {
          buttonColorStyle = "style=\"color:" + (this.options.buttonColor) + "\"";
      }
      else if (this.options.buttonColor !== '') {
          buttonColorClass = "mdui-text-color-" + (this.options.buttonColor);
      }
      // 添加 HTML
      this.$element = $('<div class="mdui-snackbar">' +
          "<div class=\"mdui-snackbar-text\">" + (this.options.message) + "</div>" +
          (this.options.buttonText
              ? ("<a href=\"javascript:void(0)\" class=\"mdui-snackbar-action mdui-btn mdui-ripple mdui-ripple-white " + buttonColorClass + "\" " + buttonColorStyle + ">" + (this.options.buttonText) + "</a>")
              : '') +
          '</div>').appendTo(document.body);
      // 设置位置
      this.setPosition('close');
      this.$element.reflow().addClass(("mdui-snackbar-" + (this.options.position)));
  };
  /**
   * 点击 Snackbar 外面的区域关闭
   * @param event
   */
  Snackbar.prototype.closeOnOutsideClick = function closeOnOutsideClick (event) {
      var $target = $(event.target);
      if (!$target.hasClass('mdui-snackbar') &&
          !$target.parents('.mdui-snackbar').length) {
          currentInst$1.close();
      }
  };
  /**
   * 设置 Snackbar 的位置
   * @param state
   */
  Snackbar.prototype.setPosition = function setPosition (state) {
      var snackbarHeight = this.$element[0].clientHeight;
      var position = this.options.position;
      var translateX;
      var translateY;
      // translateX
      if (position === 'bottom' || position === 'top') {
          translateX = '-50%';
      }
      else {
          translateX = '0';
      }
      // translateY
      if (state === 'open') {
          translateY = '0';
      }
      else {
          if (position === 'bottom') {
              translateY = snackbarHeight;
          }
          if (position === 'top') {
              translateY = -snackbarHeight;
          }
          if (position === 'left-top' || position === 'right-top') {
              translateY = -snackbarHeight - 24;
          }
          if (position === 'left-bottom' || position === 'right-bottom') {
              translateY = snackbarHeight + 24;
          }
      }
      this.$element.transform(("translate(" + translateX + "," + translateY + "px"));
  };
  /**
   * 打开 Snackbar
   */
  Snackbar.prototype.open = function open () {
          var this$1 = this;

      if (this.state === 'opening' || this.state === 'opened') {
          return;
      }
      // 如果当前有正在显示的 Snackbar，则先加入队列，等旧 Snackbar 关闭后再打开
      if (currentInst$1) {
          queue(queueName$1, function () { return this$1.open(); });
          return;
      }
      currentInst$1 = this;
      // 开始打开
      this.state = 'opening';
      this.options.onOpen(this);
      this.setPosition('open');
      this.$element.transitionEnd(function () {
          if (this$1.state !== 'opening') {
              return;
          }
          this$1.state = 'opened';
          this$1.options.onOpened(this$1);
          // 有按钮时绑定事件
          if (this$1.options.buttonText) {
              this$1.$element.find('.mdui-snackbar-action').on('click', function () {
                  this$1.options.onButtonClick(this$1);
                  if (this$1.options.closeOnButtonClick) {
                      this$1.close();
                  }
              });
          }
          // 点击 snackbar 的事件
          this$1.$element.on('click', function (event) {
              if (!$(event.target).hasClass('mdui-snackbar-action')) {
                  this$1.options.onClick(this$1);
              }
          });
          // 点击 Snackbar 外面的区域关闭
          if (this$1.options.closeOnOutsideClick) {
              $document.on(startEvent, this$1.closeOnOutsideClick);
          }
          // 超时后自动关闭
          if (this$1.options.timeout) {
              this$1.timeoutId = setTimeout(function () { return this$1.close(); }, this$1.options.timeout);
          }
      });
  };
  /**
   * 关闭 Snackbar
   */
  Snackbar.prototype.close = function close () {
          var this$1 = this;

      if (this.state === 'closing' || this.state === 'closed') {
          return;
      }
      if (this.timeoutId) {
          clearTimeout(this.timeoutId);
      }
      if (this.options.closeOnOutsideClick) {
          $document.off(startEvent, this.closeOnOutsideClick);
      }
      this.state = 'closing';
      this.options.onClose(this);
      this.setPosition('close');
      this.$element.transitionEnd(function () {
          if (this$1.state !== 'closing') {
              return;
          }
          currentInst$1 = null;
          this$1.state = 'closed';
          this$1.options.onClosed(this$1);
          this$1.$element.remove();
          dequeue(queueName$1);
      });
  };
  mdui.snackbar = function (message, options) {
      if ( options === void 0 ) options = {};

      if (isString(message)) {
          options.message = message;
      }
      else {
          options = message;
      }
      var instance = new Snackbar(options);
      instance.open();
      return instance;
  };

  $(function () {
      // 切换导航项
      $document.on('click', '.mdui-bottom-nav>a', function () {
          var $item = $(this);
          var $bottomNav = $item.parent();
          $bottomNav.children('a').each(function (index, item) {
              var isThis = $item.is(item);
              if (isThis) {
                  componentEvent('change', 'bottomNav', $bottomNav[0], undefined, {
                      index: index,
                  });
              }
              isThis
                  ? $(item).addClass('mdui-bottom-nav-active')
                  : $(item).removeClass('mdui-bottom-nav-active');
          });
      });
      // 滚动时隐藏 mdui-bottom-nav-scroll-hide
      mdui.mutation('.mdui-bottom-nav-scroll-hide', function () {
          new mdui.Headroom(this, {
              pinnedClass: 'mdui-headroom-pinned-down',
              unpinnedClass: 'mdui-headroom-unpinned-down',
          });
      });
  });

  /**
   * layer 的 HTML 结构
   * @param index
   */
  function layerHTML(index) {
      if ( index === void 0 ) index = false;

      return ("<div class=\"mdui-spinner-layer " + (index ? ("mdui-spinner-layer-" + index) : '') + "\">" +
          '<div class="mdui-spinner-circle-clipper mdui-spinner-left">' +
          '<div class="mdui-spinner-circle"></div>' +
          '</div>' +
          '<div class="mdui-spinner-gap-patch">' +
          '<div class="mdui-spinner-circle"></div>' +
          '</div>' +
          '<div class="mdui-spinner-circle-clipper mdui-spinner-right">' +
          '<div class="mdui-spinner-circle"></div>' +
          '</div>' +
          '</div>');
  }
  /**
   * 填充 HTML
   * @param spinner
   */
  function fillHTML(spinner) {
      var $spinner = $(spinner);
      var layer = $spinner.hasClass('mdui-spinner-colorful')
          ? layerHTML(1) + layerHTML(2) + layerHTML(3) + layerHTML(4)
          : layerHTML();
      $spinner.html(layer);
  }
  $(function () {
      // 页面加载完后自动填充 HTML 结构
      mdui.mutation('.mdui-spinner', function () {
          fillHTML(this);
      });
  });
  mdui.updateSpinners = function (selector) {
      var $elements = isUndefined(selector) ? $('.mdui-spinner') : $(selector);
      $elements.each(function () {
          fillHTML(this);
      });
  };

  var DEFAULT_OPTIONS$d = {
      position: 'auto',
      align: 'auto',
      gutter: 16,
      fixed: false,
      covered: 'auto',
      subMenuTrigger: 'hover',
      subMenuDelay: 200,
  };
  var Menu = function Menu(anchorSelector, menuSelector, options) {
      var this$1 = this;
      if ( options === void 0 ) options = {};

      /**
       * 配置参数
       */
      this.options = extend({}, DEFAULT_OPTIONS$d);
      /**
       * 当前菜单状态
       */
      this.state = 'closed';
      this.$anchor = $(anchorSelector).first();
      this.$element = $(menuSelector).first();
      // 触发菜单的元素 和 菜单必须是同级的元素，否则菜单可能不能定位
      if (!this.$anchor.parent().is(this.$element.parent())) {
          throw new Error('anchorSelector and menuSelector must be siblings');
      }
      extend(this.options, options);
      // 是否是级联菜单
      this.isCascade = this.$element.hasClass('mdui-menu-cascade');
      // covered 参数处理
      this.isCovered =
          this.options.covered === 'auto' ? !this.isCascade : this.options.covered;
      // 点击触发菜单切换
      this.$anchor.on('click', function () { return this$1.toggle(); });
      // 点击菜单外面区域关闭菜单
      $document.on('click touchstart', function (event) {
          var $target = $(event.target);
          if (this$1.isOpen() &&
              !$target.is(this$1.$element) &&
              !contains(this$1.$element[0], $target[0]) &&
              !$target.is(this$1.$anchor) &&
              !contains(this$1.$anchor[0], $target[0])) {
              this$1.close();
          }
      });
      // 点击不含子菜单的菜单条目关闭菜单
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      $document.on('click', '.mdui-menu-item', function () {
          var $item = $(this);
          if (!$item.find('.mdui-menu').length &&
              $item.attr('disabled') === undefined) {
              that.close();
          }
      });
      // 绑定点击或鼠标移入含子菜单的条目的事件
      this.bindSubMenuEvent();
      // 窗口大小变化时，重新调整菜单位置
      $window.on('resize', $.throttle(function () { return this$1.readjust(); }, 100));
  };
  /**
   * 是否为打开状态
   */
  Menu.prototype.isOpen = function isOpen () {
      return this.state === 'opening' || this.state === 'opened';
  };
  /**
   * 触发组件事件
   * @param name
   */
  Menu.prototype.triggerEvent = function triggerEvent (name) {
      componentEvent(name, 'menu', this.$element, this);
  };
  /**
   * 调整主菜单位置
   */
  Menu.prototype.readjust = function readjust () {
      var menuLeft;
      var menuTop;
      // 菜单位置和方向
      var position;
      var align;
      // window 窗口的宽度和高度
      var windowHeight = $window.height();
      var windowWidth = $window.width();
      // 配置参数
      var gutter = this.options.gutter;
      var isCovered = this.isCovered;
      var isFixed = this.options.fixed;
      // 动画方向参数
      var transformOriginX;
      var transformOriginY;
      // 菜单的原始宽度和高度
      var menuWidth = this.$element.width();
      var menuHeight = this.$element.height();
      // 触发菜单的元素在窗口中的位置
      var anchorRect = this.$anchor[0].getBoundingClientRect();
      var anchorTop = anchorRect.top;
      var anchorLeft = anchorRect.left;
      var anchorHeight = anchorRect.height;
      var anchorWidth = anchorRect.width;
      var anchorBottom = windowHeight - anchorTop - anchorHeight;
      var anchorRight = windowWidth - anchorLeft - anchorWidth;
      // 触发元素相对其拥有定位属性的父元素的位置
      var anchorOffsetTop = this.$anchor[0].offsetTop;
      var anchorOffsetLeft = this.$anchor[0].offsetLeft;
      // 自动判断菜单位置
      if (this.options.position === 'auto') {
          if (anchorBottom + (isCovered ? anchorHeight : 0) > menuHeight + gutter) {
              // 判断下方是否放得下菜单
              position = 'bottom';
          }
          else if (anchorTop + (isCovered ? anchorHeight : 0) >
              menuHeight + gutter) {
              // 判断上方是否放得下菜单
              position = 'top';
          }
          else {
              // 上下都放不下，居中显示
              position = 'center';
          }
      }
      else {
          position = this.options.position;
      }
      // 自动判断菜单对齐方式
      if (this.options.align === 'auto') {
          if (anchorRight + anchorWidth > menuWidth + gutter) {
              // 判断右侧是否放得下菜单
              align = 'left';
          }
          else if (anchorLeft + anchorWidth > menuWidth + gutter) {
              // 判断左侧是否放得下菜单
              align = 'right';
          }
          else {
              // 左右都放不下，居中显示
              align = 'center';
          }
      }
      else {
          align = this.options.align;
      }
      // 设置菜单位置
      if (position === 'bottom') {
          transformOriginY = '0';
          menuTop =
              (isCovered ? 0 : anchorHeight) +
                  (isFixed ? anchorTop : anchorOffsetTop);
      }
      else if (position === 'top') {
          transformOriginY = '100%';
          menuTop =
              (isCovered ? anchorHeight : 0) +
                  (isFixed ? anchorTop - menuHeight : anchorOffsetTop - menuHeight);
      }
      else {
          transformOriginY = '50%';
          // =====================在窗口中居中
          // 显示的菜单的高度，简单菜单高度不超过窗口高度，若超过了则在菜单内部显示滚动条
          // 级联菜单内部不允许出现滚动条
          var menuHeightTemp = menuHeight;
          // 简单菜单比窗口高时，限制菜单高度
          if (!this.isCascade) {
              if (menuHeight + gutter * 2 > windowHeight) {
                  menuHeightTemp = windowHeight - gutter * 2;
                  this.$element.height(menuHeightTemp);
              }
          }
          menuTop =
              (windowHeight - menuHeightTemp) / 2 +
                  (isFixed ? 0 : anchorOffsetTop - anchorTop);
      }
      this.$element.css('top', (menuTop + "px"));
      // 设置菜单对齐方式
      if (align === 'left') {
          transformOriginX = '0';
          menuLeft = isFixed ? anchorLeft : anchorOffsetLeft;
      }
      else if (align === 'right') {
          transformOriginX = '100%';
          menuLeft = isFixed
              ? anchorLeft + anchorWidth - menuWidth
              : anchorOffsetLeft + anchorWidth - menuWidth;
      }
      else {
          transformOriginX = '50%';
          //=======================在窗口中居中
          // 显示的菜单的宽度，菜单宽度不能超过窗口宽度
          var menuWidthTemp = menuWidth;
          // 菜单比窗口宽，限制菜单宽度
          if (menuWidth + gutter * 2 > windowWidth) {
              menuWidthTemp = windowWidth - gutter * 2;
              this.$element.width(menuWidthTemp);
          }
          menuLeft =
              (windowWidth - menuWidthTemp) / 2 +
                  (isFixed ? 0 : anchorOffsetLeft - anchorLeft);
      }
      this.$element.css('left', (menuLeft + "px"));
      // 设置菜单动画方向
      this.$element.transformOrigin((transformOriginX + " " + transformOriginY));
  };
  /**
   * 调整子菜单的位置
   * @param $submenu
   */
  Menu.prototype.readjustSubmenu = function readjustSubmenu ($submenu) {
      var $item = $submenu.parent('.mdui-menu-item');
      var submenuTop;
      var submenuLeft;
      // 子菜单位置和方向
      var position;
      var align;
      // window 窗口的宽度和高度
      var windowHeight = $window.height();
      var windowWidth = $window.width();
      // 动画方向参数
      var transformOriginX;
      var transformOriginY;
      // 子菜单的原始宽度和高度
      var submenuWidth = $submenu.width();
      var submenuHeight = $submenu.height();
      // 触发子菜单的菜单项的宽度高度
      var itemRect = $item[0].getBoundingClientRect();
      var itemWidth = itemRect.width;
      var itemHeight = itemRect.height;
      var itemLeft = itemRect.left;
      var itemTop = itemRect.top;
      // 判断菜单上下位置
      if (windowHeight - itemTop > submenuHeight) {
          // 判断下方是否放得下菜单
          position = 'bottom';
      }
      else if (itemTop + itemHeight > submenuHeight) {
          // 判断上方是否放得下菜单
          position = 'top';
      }
      else {
          // 默认放在下方
          position = 'bottom';
      }
      // 判断菜单左右位置
      if (windowWidth - itemLeft - itemWidth > submenuWidth) {
          // 判断右侧是否放得下菜单
          align = 'left';
      }
      else if (itemLeft > submenuWidth) {
          // 判断左侧是否放得下菜单
          align = 'right';
      }
      else {
          // 默认放在右侧
          align = 'left';
      }
      // 设置菜单位置
      if (position === 'bottom') {
          transformOriginY = '0';
          submenuTop = '0';
      }
      else if (position === 'top') {
          transformOriginY = '100%';
          submenuTop = -submenuHeight + itemHeight;
      }
      $submenu.css('top', (submenuTop + "px"));
      // 设置菜单对齐方式
      if (align === 'left') {
          transformOriginX = '0';
          submenuLeft = itemWidth;
      }
      else if (align === 'right') {
          transformOriginX = '100%';
          submenuLeft = -submenuWidth;
      }
      $submenu.css('left', (submenuLeft + "px"));
      // 设置菜单动画方向
      $submenu.transformOrigin((transformOriginX + " " + transformOriginY));
  };
  /**
   * 打开子菜单
   * @param $submenu
   */
  Menu.prototype.openSubMenu = function openSubMenu ($submenu) {
      this.readjustSubmenu($submenu);
      $submenu
          .addClass('mdui-menu-open')
          .parent('.mdui-menu-item')
          .addClass('mdui-menu-item-active');
  };
  /**
   * 关闭子菜单，及其嵌套的子菜单
   * @param $submenu
   */
  Menu.prototype.closeSubMenu = function closeSubMenu ($submenu) {
      // 关闭子菜单
      $submenu
          .removeClass('mdui-menu-open')
          .addClass('mdui-menu-closing')
          .transitionEnd(function () { return $submenu.removeClass('mdui-menu-closing'); })
          // 移除激活状态的样式
          .parent('.mdui-menu-item')
          .removeClass('mdui-menu-item-active');
      // 循环关闭嵌套的子菜单
      $submenu.find('.mdui-menu').each(function (_, menu) {
          var $subSubmenu = $(menu);
          $subSubmenu
              .removeClass('mdui-menu-open')
              .addClass('mdui-menu-closing')
              .transitionEnd(function () { return $subSubmenu.removeClass('mdui-menu-closing'); })
              .parent('.mdui-menu-item')
              .removeClass('mdui-menu-item-active');
      });
  };
  /**
   * 切换子菜单状态
   * @param $submenu
   */
  Menu.prototype.toggleSubMenu = function toggleSubMenu ($submenu) {
      $submenu.hasClass('mdui-menu-open')
          ? this.closeSubMenu($submenu)
          : this.openSubMenu($submenu);
  };
  /**
   * 绑定子菜单事件
   */
  Menu.prototype.bindSubMenuEvent = function bindSubMenuEvent () {
      // eslint-disable-next-line @typescript-eslint/no-this-alias
      var that = this;
      // 点击打开子菜单
      this.$element.on('click', '.mdui-menu-item', function (event) {
          var $item = $(this);
          var $target = $(event.target);
          // 禁用状态菜单不操作
          if ($item.attr('disabled') !== undefined) {
              return;
          }
          // 没有点击在子菜单的菜单项上时，不操作（点在了子菜单的空白区域、或分隔线上）
          if ($target.is('.mdui-menu') || $target.is('.mdui-divider')) {
              return;
          }
          // 阻止冒泡，点击菜单项时只在最后一级的 mdui-menu-item 上生效，不向上冒泡
          if (!$target.parents('.mdui-menu-item').first().is($item)) {
              return;
          }
          // 当前菜单的子菜单
          var $submenu = $item.children('.mdui-menu');
          // 先关闭除当前子菜单外的所有同级子菜单
          $item
              .parent('.mdui-menu')
              .children('.mdui-menu-item')
              .each(function (_, item) {
              var $tmpSubmenu = $(item).children('.mdui-menu');
              if ($tmpSubmenu.length &&
                  (!$submenu.length || !$tmpSubmenu.is($submenu))) {
                  that.closeSubMenu($tmpSubmenu);
              }
          });
          // 切换当前子菜单
          if ($submenu.length) {
              that.toggleSubMenu($submenu);
          }
      });
      if (this.options.subMenuTrigger === 'hover') {
          // 临时存储 setTimeout 对象
          var timeout = null;
          var timeoutOpen = null;
          this.$element.on('mouseover mouseout', '.mdui-menu-item', function (event) {
              var $item = $(this);
              var eventType = event.type;
              var $relatedTarget = $(event.relatedTarget);
              // 禁用状态的菜单不操作
              if ($item.attr('disabled') !== undefined) {
                  return;
              }
              // 用 mouseover 模拟 mouseenter
              if (eventType === 'mouseover') {
                  if (!$item.is($relatedTarget) &&
                      contains($item[0], $relatedTarget[0])) {
                      return;
                  }
              }
              // 用 mouseout 模拟 mouseleave
              else if (eventType === 'mouseout') {
                  if ($item.is($relatedTarget) ||
                      contains($item[0], $relatedTarget[0])) {
                      return;
                  }
              }
              // 当前菜单项下的子菜单，未必存在
              var $submenu = $item.children('.mdui-menu');
              // 鼠标移入菜单项时，显示菜单项下的子菜单
              if (eventType === 'mouseover') {
                  if ($submenu.length) {
                      // 当前子菜单准备打开时，如果当前子菜单正准备着关闭，不用再关闭了
                      var tmpClose = $submenu.data('timeoutClose.mdui.menu');
                      if (tmpClose) {
                          clearTimeout(tmpClose);
                      }
                      // 如果当前子菜单已经打开，不操作
                      if ($submenu.hasClass('mdui-menu-open')) {
                          return;
                      }
                      // 当前子菜单准备打开时，其他准备打开的子菜单不用再打开了
                      clearTimeout(timeoutOpen);
                      // 准备打开当前子菜单
                      timeout = timeoutOpen = setTimeout(function () { return that.openSubMenu($submenu); }, that.options.subMenuDelay);
                      $submenu.data('timeoutOpen.mdui.menu', timeout);
                  }
              }
              // 鼠标移出菜单项时，关闭菜单项下的子菜单
              else if (eventType === 'mouseout') {
                  if ($submenu.length) {
                      // 鼠标移出菜单项时，如果当前菜单项下的子菜单正准备打开，不用再打开了
                      var tmpOpen = $submenu.data('timeoutOpen.mdui.menu');
                      if (tmpOpen) {
                          clearTimeout(tmpOpen);
                      }
                      // 准备关闭当前子菜单
                      timeout = setTimeout(function () { return that.closeSubMenu($submenu); }, that.options.subMenuDelay);
                      $submenu.data('timeoutClose.mdui.menu', timeout);
                  }
              }
          });
      }
  };
  /**
   * 动画结束回调
   */
  Menu.prototype.transitionEnd = function transitionEnd () {
      this.$element.removeClass('mdui-menu-closing');
      if (this.state === 'opening') {
          this.state = 'opened';
          this.triggerEvent('opened');
      }
      if (this.state === 'closing') {
          this.state = 'closed';
          this.triggerEvent('closed');
          // 关闭后，恢复菜单样式到默认状态，并恢复 fixed 定位
          this.$element.css({
              top: '',
              left: '',
              width: '',
              position: 'fixed',
          });
      }
  };
  /**
   * 切换菜单状态
   */
  Menu.prototype.toggle = function toggle () {
      this.isOpen() ? this.close() : this.open();
  };
  /**
   * 打开菜单
   */
  Menu.prototype.open = function open () {
          var this$1 = this;

      if (this.isOpen()) {
          return;
      }
      this.state = 'opening';
      this.triggerEvent('open');
      this.readjust();
      this.$element
          // 菜单隐藏状态使用使用 fixed 定位。
          .css('position', this.options.fixed ? 'fixed' : 'absolute')
          .addClass('mdui-menu-open')
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  /**
   * 关闭菜单
   */
  Menu.prototype.close = function close () {
          var this$1 = this;

      if (!this.isOpen()) {
          return;
      }
      this.state = 'closing';
      this.triggerEvent('close');
      // 菜单开始关闭时，关闭所有子菜单
      this.$element.find('.mdui-menu').each(function (_, submenu) {
          this$1.closeSubMenu($(submenu));
      });
      this.$element
          .removeClass('mdui-menu-open')
          .addClass('mdui-menu-closing')
          .transitionEnd(function () { return this$1.transitionEnd(); });
  };
  mdui.Menu = Menu;

  var customAttr$9 = 'mdui-menu';
  var dataName$3 = '_mdui_menu';
  $(function () {
      $document.on('click', ("[" + customAttr$9 + "]"), function () {
          var $this = $(this);
          var instance = $this.data(dataName$3);
          if (!instance) {
              var options = parseOptions(this, customAttr$9);
              var menuSelector = options.target;
              // @ts-ignore
              delete options.target;
              instance = new mdui.Menu($this, menuSelector, options);
              $this.data(dataName$3, instance);
              instance.toggle();
          }
      });
  });

  return mdui;

})));
//# sourceMappingURL=mdui.js.map
