// ==UserScript==
// @name         网页截屏
// @namespace    https://github.com/CListery
// @version      0.9
// @description  将选中元素截屏
// @license      MIT
// @author       CListery
// @require      https://cdn.jsdelivr.net/npm/html2canvas@1/dist/html2canvas.min.js
// @require      https://cdn.jsdelivr.net/npm/jquery@3/dist/jquery.min.js
// @require      https://cdn.jsdelivr.net/npm/luna-dom-highlighter@1.0.2/luna-dom-highlighter.js
// @resource     lunaDomHighlighterCSS  https://cdn.jsdelivr.net/npm/luna-dom-highlighter/luna-dom-highlighter.css
// @match        *://*/*
// @icon         data:image/svg+xml;base64,PHN2ZyBmaWxsPSIjZmZmZmZmIiBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjMuMiIvPgogICAgPHBhdGggZD0iTTkgMkw3LjE3IDRINGMtMS4xIDAtMiAuOS0yIDJ2MTJjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY2YzAtMS4xLS45LTItMi0yaC0zLjE3TDE1IDJIOXptMyAxNWMtMi43NiAwLTUtMi4yNC01LTVzMi4yNC01IDUtNSA1IDIuMjQgNSA1LTIuMjQgNS01IDV6Ii8+CiAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIi8+Cjwvc3ZnPgo=
// @grant        GM.getResourceUrl
// @grant        GM.getResourceText
// @grant        GM_getResourceText
// @downloadURL https://update.greasyfork.icu/scripts/493588/%E7%BD%91%E9%A1%B5%E6%88%AA%E5%B1%8F.user.js
// @updateURL https://update.greasyfork.icu/scripts/493588/%E7%BD%91%E9%A1%B5%E6%88%AA%E5%B1%8F.meta.js
// ==/UserScript==

;(function () {
    'use strict',
      // licia libraries
      // Built by eustia.
      // included: h toBool evalCss root cssSupports $ contain defaults
      (function (root, factory) {
        if (typeof define === 'function' && define.amd) {
          define([], factory)
        } else if (typeof module === 'object' && module.exports) {
          module.exports = factory()
        } else {
          root._licia = factory()
        }
      })(this, function () {
        /* eslint-disable */
  
        var _licia = {}
  
        if (typeof window === 'object' && window._licia) _licia = window._licia
  
        /* ------------------------------ last ------------------------------ */
  
        var last = (_licia.last = (function (exports) {
          /* Get the last element of array.
           *
           * |Name  |Desc                     |
           * |------|-------------------------|
           * |arr   |The array to query       |
           * |return|The last element of array|
           */
  
          /* example
           * last([1, 2]); // -> 2
           */
  
          /* typescript
           * export declare function last(arr: any[]): any;
           */
  
          exports = function (arr) {
            var len = arr ? arr.length : 0
            if (len) return arr[len - 1]
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isUndef ------------------------------ */
  
        var isUndef = (_licia.isUndef = (function (exports) {
          /* Check if value is undefined.
           *
           * |Name  |Desc                      |
           * |------|--------------------------|
           * |val   |Value to check            |
           * |return|True if value is undefined|
           */
  
          /* example
           * isUndef(void 0); // -> true
           * isUndef(null); // -> false
           */
  
          /* typescript
           * export declare function isUndef(val: any): val is undefined;
           */
  
          exports = function (val) {
            return val === void 0
          }
  
          return exports
        })({}))
  
        /* ------------------------------ types ------------------------------ */
  
        var types = (_licia.types = (function (exports) {
          /* Used for typescript definitions only.
           */
  
          /* typescript
           * export declare namespace types {
           *     interface Collection<T> {}
           *     interface List<T> extends Collection<T> {
           *         [index: number]: T;
           *         length: number;
           *     }
           *     interface ListIterator<T, TResult> {
           *         (value: T, index: number, list: List<T>): TResult;
           *     }
           *     interface Dictionary<T> extends Collection<T> {
           *         [index: string]: T;
           *     }
           *     interface ObjectIterator<T, TResult> {
           *         (element: T, key: string, list: Dictionary<T>): TResult;
           *     }
           *     interface MemoIterator<T, TResult> {
           *         (prev: TResult, curr: T, index: number, list: List<T>): TResult;
           *     }
           *     interface MemoObjectIterator<T, TResult> {
           *         (prev: TResult, curr: T, key: string, list: Dictionary<T>): TResult;
           *     }
           *     type Fn<T> = (...args: any[]) => T;
           *     type AnyFn = Fn<any>;
           *     type PlainObj<T> = { [name: string]: T };
           * }
           * export declare const types: {};
           */
  
          exports = {}
  
          return exports
        })({}))
  
        /* ------------------------------ isObj ------------------------------ */
  
        var isObj = (_licia.isObj = (function (exports) {
          /* Check if value is the language type of Object.
           *
           * |Name  |Desc                      |
           * |------|--------------------------|
           * |val   |Value to check            |
           * |return|True if value is an object|
           *
           * [Language Spec](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)
           */
  
          /* example
           * isObj({}); // -> true
           * isObj([]); // -> true
           */
  
          /* typescript
           * export declare function isObj(val: any): boolean;
           */
  
          exports = function (val) {
            var type = typeof val
            return !!val && (type === 'function' || type === 'object')
          }
  
          return exports
        })({}))
  
        /* ------------------------------ splitCase ------------------------------ */
  
        var splitCase = (_licia.splitCase = (function (exports) {
          /* Split different string case to an array.
           *
           * |Name  |Desc           |
           * |------|---------------|
           * |str   |String to split|
           * |return|Result array   |
           */
  
          /* example
           * splitCase('foo-bar'); // -> ['foo', 'bar']
           * splitCase('foo bar'); // -> ['foo', 'bar']
           * splitCase('foo_bar'); // -> ['foo', 'bar']
           * splitCase('foo.bar'); // -> ['foo', 'bar']
           * splitCase('fooBar'); // -> ['foo', 'bar']
           * splitCase('foo-Bar'); // -> ['foo', 'bar']
           */
  
          /* typescript
           * export declare function splitCase(str: string): string[];
           */
  
          var regUpperCase = /([A-Z])/g
          var regSeparator = /[_.\- ]+/g
          var regTrim = /(^-)|(-$)/g
          exports = function (str) {
            str = str
              .replace(regUpperCase, '-$1')
              .toLowerCase()
              .replace(regSeparator, '-')
              .replace(regTrim, '')
            return str.split('-')
          }
  
          return exports
        })({}))
  
        /* ------------------------------ camelCase ------------------------------ */
  
        var camelCase = (_licia.camelCase = (function (exports) {
          /* Convert string to "camelCase".
           *
           * |Name  |Desc              |
           * |------|------------------|
           * |str   |String to convert |
           * |return|Camel cased string|
           */
  
          /* example
           * camelCase('foo-bar'); // -> fooBar
           * camelCase('foo bar'); // -> fooBar
           * camelCase('foo_bar'); // -> fooBar
           * camelCase('foo.bar'); // -> fooBar
           */
  
          /* typescript
           * export declare function camelCase(str: string): string;
           */
  
          /* dependencies
           * splitCase
           */
          exports = function (str) {
            var arr = splitCase(str)
            var ret = arr[0]
            arr.shift()
            arr.forEach(capitalize, arr)
            ret += arr.join('')
            return ret
          }
          function capitalize(val, idx) {
            this[idx] = val.replace(/\w/, function (match) {
              return match.toUpperCase()
            })
          }
  
          return exports
        })({}))
  
        /* ------------------------------ kebabCase ------------------------------ */
  
        var kebabCase = (_licia.kebabCase = (function (exports) {
          /* Convert string to "kebabCase".
           *
           * |Name  |Desc              |
           * |------|------------------|
           * |str   |String to convert |
           * |return|Kebab cased string|
           */
  
          /* example
           * kebabCase('fooBar'); // -> foo-bar
           * kebabCase('foo bar'); // -> foo-bar
           * kebabCase('foo_bar'); // -> foo-bar
           * kebabCase('foo.bar'); // -> foo-bar
           */
  
          /* typescript
           * export declare function kebabCase(str: string): string;
           */
  
          /* dependencies
           * splitCase
           */
          exports = function (str) {
            return splitCase(str).join('-')
          }
  
          return exports
        })({}))
  
        /* ------------------------------ has ------------------------------ */
  
        var has = (_licia.has = (function (exports) {
          /* Checks if key is a direct property.
           *
           * |Name  |Desc                            |
           * |------|--------------------------------|
           * |obj   |Object to query                 |
           * |key   |Path to check                   |
           * |return|True if key is a direct property|
           */
  
          /* example
           * has({ one: 1 }, 'one'); // -> true
           */
  
          /* typescript
           * export declare function has(obj: {}, key: string): boolean;
           */
  
          var hasOwnProp = Object.prototype.hasOwnProperty
          exports = function (obj, key) {
            return hasOwnProp.call(obj, key)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ keys ------------------------------ */
  
        var keys = (_licia.keys = (function (exports) {
          /* Create an array of the own enumerable property names of object.
           *
           * |Name  |Desc                   |
           * |------|-----------------------|
           * |obj   |Object to query        |
           * |return|Array of property names|
           */
  
          /* example
           * keys({ a: 1 }); // -> ['a']
           */
  
          /* typescript
           * export declare function keys(obj: any): string[];
           */
  
          /* dependencies
           * has
           */
          if (Object.keys && !false) {
            exports = Object.keys
          } else {
            exports = function (obj) {
              var ret = []
              for (var key in obj) {
                if (has(obj, key)) ret.push(key)
              }
              return ret
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ idxOf ------------------------------ */
  
        var idxOf = (_licia.idxOf = (function (exports) {
          /* Get the index at which the first occurrence of value.
           *
           * |Name     |Desc                |
           * |---------|--------------------|
           * |arr      |Array to search     |
           * |val      |Value to search for |
           * |fromIdx=0|Index to search from|
           * |return   |Value index         |
           */
  
          /* example
           * idxOf([1, 2, 1, 2], 2, 2); // -> 3
           */
  
          /* typescript
           * export declare function idxOf(arr: any[], val: any, fromIdx?: number): number;
           */
  
          exports = function (arr, val, fromIdx) {
            return Array.prototype.indexOf.call(arr, val, fromIdx)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ create ------------------------------ */
  
        var create = (_licia.create = (function (exports) {
          /* Create new object using given object as prototype.
           *
           * |Name  |Desc                   |
           * |------|-----------------------|
           * |proto |Prototype of new object|
           * |return|Created object         |
           */
  
          /* example
           * const obj = create({ a: 1 });
           * console.log(obj.a); // -> 1
           */
  
          /* typescript
           * export declare function create(proto?: object): any;
           */
  
          /* dependencies
           * isObj
           */
          exports = function (proto) {
            if (!isObj(proto)) return {}
            if (objCreate && !false) return objCreate(proto)
            function noop() {}
            noop.prototype = proto
            return new noop()
          }
          var objCreate = Object.create
  
          return exports
        })({}))
  
        /* ------------------------------ inherits ------------------------------ */
  
        var inherits = (_licia.inherits = (function (exports) {
          /* Inherit the prototype methods from one constructor into another.
           *
           * |Name      |Desc       |
           * |----------|-----------|
           * |Class     |Child Class|
           * |SuperClass|Super Class|
           */
  
          /* example
           * function People(name) {
           *     this._name = name;
           * }
           * People.prototype = {
           *     getName: function() {
           *         return this._name;
           *     }
           * };
           * function Student(name) {
           *     this._name = name;
           * }
           * inherits(Student, People);
           * const s = new Student('RedHood');
           * s.getName(); // -> 'RedHood'
           */
  
          /* typescript
           * export declare function inherits(
           *     Class: types.AnyFn,
           *     SuperClass: types.AnyFn
           * ): void;
           */
  
          /* dependencies
           * create types
           */
          exports = function (Class, SuperClass) {
            Class.prototype = create(SuperClass.prototype)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ memoize ------------------------------ */
  
        var memoize = (_licia.memoize = (function (exports) {
          /* Memoize a given function by caching the computed result.
           *
           * |Name  |Desc                                |
           * |------|------------------------------------|
           * |fn    |Function to have its output memoized|
           * |hashFn|Function to create cache key        |
           * |return|New memoized function               |
           */
  
          /* example
           * const fibonacci = memoize(function(n) {
           *     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
           * });
           */
  
          /* typescript
           * export declare function memoize(
           *     fn: types.AnyFn,
           *     hashFn?: types.AnyFn
           * ): types.AnyFn;
           */
  
          /* dependencies
           * has types
           */
          exports = function (fn, hashFn) {
            var memoize = function (key) {
              var cache = memoize.cache
              var address = '' + (hashFn ? hashFn.apply(this, arguments) : key)
              if (!has(cache, address)) cache[address] = fn.apply(this, arguments)
              return cache[address]
            }
            memoize.cache = {}
            return memoize
          }
  
          return exports
        })({}))
  
        /* ------------------------------ cssSupports ------------------------------ */
        _licia.cssSupports = (function (exports) {
          /* Check if browser supports a given CSS feature.
           *
           * |Name  |Desc              |
           * |------|------------------|
           * |name  |Css property name |
           * |val   |Css property value|
           * |return|True if supports  |
           */
  
          /* example
           * cssSupports('display', 'flex'); // -> true
           * cssSupports('display', 'invalid'); // -> false
           * cssSupports('text-decoration-line', 'underline'); // -> true
           * cssSupports('grid'); // -> true
           * cssSupports('invalid'); // -> false
           */
  
          /* typescript
           * export declare function cssSupports(name: string, val?: string): boolean;
           */
  
          /* dependencies
           * memoize isUndef camelCase
           */
          exports = memoize(
            function (name, value) {
              if (isUndef(value)) {
                name = camelCase(name)
                return !isUndef(style[name])
              }
              style.cssText = ''
              style.cssText = name + ':' + value
              return !!style.length
            },
            function (name, value) {
              return name + ' ' + value
            }
          )
          var style = document.createElement('p').style
  
          return exports
        })({})
  
        /* ------------------------------ optimizeCb ------------------------------ */
  
        var optimizeCb = (_licia.optimizeCb = (function (exports) {
          /* Used for function context binding.
           */
  
          /* typescript
           * export declare function optimizeCb(
           *     fn: types.AnyFn,
           *     ctx: any,
           *     argCount?: number
           * ): types.AnyFn;
           */
  
          /* dependencies
           * isUndef types
           */
          exports = function (fn, ctx, argCount) {
            if (isUndef(ctx)) return fn
            switch (argCount == null ? 3 : argCount) {
              case 1:
                return function (val) {
                  return fn.call(ctx, val)
                }
              case 3:
                return function (val, idx, collection) {
                  return fn.call(ctx, val, idx, collection)
                }
              case 4:
                return function (accumulator, val, idx, collection) {
                  return fn.call(ctx, accumulator, val, idx, collection)
                }
            }
            return function () {
              return fn.apply(ctx, arguments)
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ evalCss ------------------------------ */
        _licia.evalCss = (function (exports) {
          /* Load css into page.
           *
           * |Name  |Desc         |
           * |------|-------------|
           * |css   |Css code     |
           * |return|Style element|
           */
  
          /* example
           * evalCss('body{background:#08c}');
           */
  
          /* typescript
           * export declare function evalCss(css: string): HTMLStyleElement;
           */
  
          exports = function (css) {
            var style = document.createElement('style')
            style.textContent = css
            style.type = 'text/css'
            document.head.appendChild(style)
            return style
          }
  
          return exports
        })({})
  
        /* ------------------------------ isEl ------------------------------ */
  
        var isEl = (_licia.isEl = (function (exports) {
          /* Check if value is a DOM element.
           *
           * |Name  |Desc                          |
           * |------|------------------------------|
           * |val   |Value to check                |
           * |return|True if value is a DOM element|
           */
  
          /* example
           * isEl(document.body); // -> true
           */
  
          /* typescript
           * export declare function isEl(val: any): val is Element;
           */
  
          exports = function (val) {
            return !!(val && val.nodeType === 1)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ startWith ------------------------------ */
  
        var startWith = (_licia.startWith = (function (exports) {
          /* Check if string starts with the given target string.
           *
           * |Name  |Desc                             |
           * |------|---------------------------------|
           * |str   |String to search                 |
           * |prefix|String prefix                    |
           * |return|True if string starts with prefix|
           */
  
          /* example
           * startWith('ab', 'a'); // -> true
           */
  
          /* typescript
           * export declare function startWith(str: string, prefix: string): boolean;
           */
  
          exports = function (str, prefix) {
            return str.indexOf(prefix) === 0
          }
  
          return exports
        })({}))
  
        /* ------------------------------ identity ------------------------------ */
  
        var identity = (_licia.identity = (function (exports) {
          /* Return the first argument given.
           *
           * |Name  |Desc       |
           * |------|-----------|
           * |val   |Any value  |
           * |return|Given value|
           */
  
          /* example
           * identity('a'); // -> 'a'
           */
  
          /* typescript
           * export declare function identity<T>(val: T): T;
           */
  
          exports = function (val) {
            return val
          }
  
          return exports
        })({}))
  
        /* ------------------------------ objToStr ------------------------------ */
  
        var objToStr = (_licia.objToStr = (function (exports) {
          /* Alias of Object.prototype.toString.
           *
           * |Name  |Desc                                |
           * |------|------------------------------------|
           * |val   |Source value                        |
           * |return|String representation of given value|
           */
  
          /* example
           * objToStr(5); // -> '[object Number]'
           */
  
          /* typescript
           * export declare function objToStr(val: any): string;
           */
  
          var ObjToStr = Object.prototype.toString
          exports = function (val) {
            return ObjToStr.call(val)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isArr ------------------------------ */
  
        var isArr = (_licia.isArr = (function (exports) {
          /* Check if value is an `Array` object.
           *
           * |Name  |Desc                              |
           * |------|----------------------------------|
           * |val   |Value to check                    |
           * |return|True if value is an `Array` object|
           */
  
          /* example
           * isArr([]); // -> true
           * isArr({}); // -> false
           */
  
          /* typescript
           * export declare function isArr(val: any): val is any[];
           */
  
          /* dependencies
           * objToStr
           */
          if (Array.isArray && !false) {
            exports = Array.isArray
          } else {
            exports = function (val) {
              return objToStr(val) === '[object Array]'
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ castPath ------------------------------ */
  
        var castPath = (_licia.castPath = (function (exports) {
          /* Cast value into a property path array.
           *
           * |Name  |Desc               |
           * |------|-------------------|
           * |path  |Value to inspect   |
           * |obj   |Object to query    |
           * |return|Property path array|
           */
  
          /* example
           * castPath('a.b.c'); // -> ['a', 'b', 'c']
           * castPath(['a']); // -> ['a']
           * castPath('a[0].b'); // -> ['a', '0', 'b']
           * castPath('a.b.c', { 'a.b.c': true }); // -> ['a.b.c']
           */
  
          /* typescript
           * export declare function castPath(path: string | string[], obj?: any): string[];
           */
  
          /* dependencies
           * has isArr
           */
          exports = function (str, obj) {
            if (isArr(str)) return str
            if (obj && has(obj, str)) return [str]
            var ret = []
            str.replace(regPropName, function (match, number, quote, str) {
              ret.push(quote ? str.replace(regEscapeChar, '$1') : number || match)
            })
            return ret
          }
  
          // Lodash _stringToPath
          var regPropName =
            /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g
          var regEscapeChar = /\\(\\)?/g
  
          return exports
        })({}))
  
        /* ------------------------------ safeGet ------------------------------ */
  
        var safeGet = (_licia.safeGet = (function (exports) {
          /* Get object property, don't throw undefined error.
           *
           * |Name  |Desc                     |
           * |------|-------------------------|
           * |obj   |Object to query          |
           * |path  |Path of property to get  |
           * |return|Target value or undefined|
           */
  
          /* example
           * const obj = { a: { aa: { aaa: 1 } } };
           * safeGet(obj, 'a.aa.aaa'); // -> 1
           * safeGet(obj, ['a', 'aa']); // -> {aaa: 1}
           * safeGet(obj, 'a.b'); // -> undefined
           */
  
          /* typescript
           * export declare function safeGet(obj: any, path: string | string[]): any;
           */
  
          /* dependencies
           * isUndef castPath
           */
          exports = function (obj, path) {
            path = castPath(path, obj)
            var prop
            prop = path.shift()
            while (!isUndef(prop)) {
              obj = obj[prop]
              if (obj == null) return
              prop = path.shift()
            }
            return obj
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isFn ------------------------------ */
  
        var isFn = (_licia.isFn = (function (exports) {
          /* Check if value is a function.
           *
           * |Name  |Desc                       |
           * |------|---------------------------|
           * |val   |Value to check             |
           * |return|True if value is a function|
           *
           * Generator function is also classified as true.
           */
  
          /* example
           * isFn(function() {}); // -> true
           * isFn(function*() {}); // -> true
           * isFn(async function() {}); // -> true
           */
  
          /* typescript
           * export declare function isFn(val: any): val is Function;
           */
  
          /* dependencies
           * objToStr
           */
          exports = function (val) {
            var objStr = objToStr(val)
            return (
              objStr === '[object Function]' ||
              objStr === '[object GeneratorFunction]' ||
              objStr === '[object AsyncFunction]'
            )
          }
  
          return exports
        })({}))
  
        /* ------------------------------ getProto ------------------------------ */
  
        var getProto = (_licia.getProto = (function (exports) {
          /* Get prototype of an object.
           *
           * |Name  |Desc                                         |
           * |------|---------------------------------------------|
           * |obj   |Target object                                |
           * |return|Prototype of given object, null if not exists|
           */
  
          /* example
           * const a = {};
           * getProto(Object.create(a)); // -> a
           */
  
          /* typescript
           * export declare function getProto(obj: any): any;
           */
  
          /* dependencies
           * isObj isFn
           */
          var getPrototypeOf = Object.getPrototypeOf
          var ObjectCtr = {}.constructor
          exports = function (obj) {
            if (!isObj(obj)) return
            if (getPrototypeOf && !false) return getPrototypeOf(obj)
            var proto = obj.__proto__
            if (proto || proto === null) return proto
            if (isFn(obj.constructor)) return obj.constructor.prototype
            if (obj instanceof ObjectCtr) return ObjectCtr.prototype
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isMiniProgram ------------------------------ */
  
        var isMiniProgram = (_licia.isMiniProgram = (function (exports) {
          /* Check if running in wechat mini program.
           */
  
          /* example
           * console.log(isMiniProgram); // -> true if running in mini program.
           */
  
          /* typescript
           * export declare const isMiniProgram: boolean;
           */
  
          /* dependencies
           * isFn
           */
  
          /* eslint-disable no-undef */
          exports = typeof wx !== 'undefined' && isFn(wx.openLocation)
  
          return exports
        })({}))
  
        /* ------------------------------ isNum ------------------------------ */
  
        var isNum = (_licia.isNum = (function (exports) {
          /* Check if value is classified as a Number primitive or object.
           *
           * |Name  |Desc                                 |
           * |------|-------------------------------------|
           * |val   |Value to check                       |
           * |return|True if value is correctly classified|
           */
  
          /* example
           * isNum(5); // -> true
           * isNum(5.1); // -> true
           * isNum({}); // -> false
           */
  
          /* typescript
           * export declare function isNum(val: any): val is number;
           */
  
          /* dependencies
           * objToStr
           */
          exports = function (val) {
            return objToStr(val) === '[object Number]'
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isArrLike ------------------------------ */
  
        var isArrLike = (_licia.isArrLike = (function (exports) {
          /* Check if value is array-like.
           *
           * |Name  |Desc                       |
           * |------|---------------------------|
           * |val   |Value to check             |
           * |return|True if value is array like|
           *
           * Function returns false.
           */
  
          /* example
           * isArrLike('test'); // -> true
           * isArrLike(document.body.children); // -> true;
           * isArrLike([1, 2, 3]); // -> true
           */
  
          /* typescript
           * export declare function isArrLike(val: any): boolean;
           */
  
          /* dependencies
           * isNum isFn
           */
          var MAX_ARR_IDX = Math.pow(2, 53) - 1
          exports = function (val) {
            if (!val) return false
            var len = val.length
            return isNum(len) && len >= 0 && len <= MAX_ARR_IDX && !isFn(val)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ each ------------------------------ */
  
        var each = (_licia.each = (function (exports) {
          /* Iterate over elements of collection and invokes iterator for each element.
           *
           * |Name    |Desc                          |
           * |--------|------------------------------|
           * |obj     |Collection to iterate over    |
           * |iterator|Function invoked per iteration|
           * |ctx     |Function context              |
           */
  
          /* example
           * each({ a: 1, b: 2 }, function(val, key) {});
           */
  
          /* typescript
           * export declare function each<T>(
           *     list: types.List<T>,
           *     iterator: types.ListIterator<T, void>,
           *     ctx?: any
           * ): types.List<T>;
           * export declare function each<T>(
           *     object: types.Dictionary<T>,
           *     iterator: types.ObjectIterator<T, void>,
           *     ctx?: any
           * ): types.Collection<T>;
           */
  
          /* dependencies
           * isArrLike keys optimizeCb types
           */
          exports = function (obj, iterator, ctx) {
            iterator = optimizeCb(iterator, ctx)
            var i, len
            if (isArrLike(obj)) {
              for (i = 0, len = obj.length; i < len; i++) iterator(obj[i], i, obj)
            } else {
              var _keys = keys(obj)
              for (i = 0, len = _keys.length; i < len; i++) {
                iterator(obj[_keys[i]], _keys[i], obj)
              }
            }
            return obj
          }
  
          return exports
        })({}))
  
        /* ------------------------------ createAssigner ------------------------------ */
  
        var createAssigner = (_licia.createAssigner = (function (exports) {
          /* Used to create extend, extendOwn and defaults.
           *
           * |Name    |Desc                          |
           * |--------|------------------------------|
           * |keysFn  |Function to get object keys   |
           * |defaults|No override when set to true  |
           * |return  |Result function, extend...    |
           */
  
          /* typescript
           * export declare function createAssigner(
           *     keysFn: types.AnyFn,
           *     defaults: boolean
           * ): types.AnyFn;
           */
  
          /* dependencies
           * isUndef each types
           */
          exports = function (keysFn, defaults) {
            return function (obj) {
              each(arguments, function (src, idx) {
                if (idx === 0) return
                var keys = keysFn(src)
                each(keys, function (key) {
                  if (!defaults || isUndef(obj[key])) obj[key] = src[key]
                })
              })
              return obj
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ extendOwn ------------------------------ */
  
        var extendOwn = (_licia.extendOwn = (function (exports) {
          /* Like extend, but only copies own properties over to the destination object.
           *
           * |Name       |Desc              |
           * |-----------|------------------|
           * |destination|Destination object|
           * |...sources |Sources objects   |
           * |return     |Destination object|
           */
  
          /* example
           * extendOwn({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}
           */
  
          /* typescript
           * export declare function extendOwn(destination: any, ...sources: any[]): any;
           */
  
          /* dependencies
           * keys createAssigner
           */
          exports = createAssigner(keys)
  
          return exports
        })({}))
  
        /* ------------------------------ values ------------------------------ */
  
        var values = (_licia.values = (function (exports) {
          /* Create an array of the own enumerable property values of object.
           *
           * |Name  |Desc                    |
           * |------|------------------------|
           * |obj   |Object to query         |
           * |return|Array of property values|
           */
  
          /* example
           * values({ one: 1, two: 2 }); // -> [1, 2]
           */
  
          /* typescript
           * export declare function values(obj: any): any[];
           */
  
          /* dependencies
           * each
           */
          exports = function (obj) {
            var ret = []
            each(obj, function (val) {
              ret.push(val)
            })
            return ret
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isStr ------------------------------ */
  
        var isStr = (_licia.isStr = (function (exports) {
          /* Check if value is a string primitive.
           *
           * |Name  |Desc                               |
           * |------|-----------------------------------|
           * |val   |Value to check                     |
           * |return|True if value is a string primitive|
           */
  
          /* example
           * isStr('licia'); // -> true
           */
  
          /* typescript
           * export declare function isStr(val: any): val is string;
           */
  
          /* dependencies
           * objToStr
           */
          exports = function (val) {
            return objToStr(val) === '[object String]'
          }
  
          return exports
        })({}))
  
        /* ------------------------------ contain ------------------------------ */
  
        var contain = (_licia.contain = (function (exports) {
          /* Check if the value is present in the list.
           *
           * |Name  |Desc                                |
           * |------|------------------------------------|
           * |target|Target object                       |
           * |val   |Value to check                      |
           * |return|True if value is present in the list|
           */
  
          /* example
           * contain([1, 2, 3], 1); // -> true
           * contain({ a: 1, b: 2 }, 1); // -> true
           * contain('abc', 'a'); // -> true
           */
  
          /* typescript
           * export declare function contain(arr: any[] | {} | string, val: any): boolean;
           */
  
          /* dependencies
           * idxOf isStr isArrLike values
           */
          exports = function (arr, val) {
            if (isStr(arr)) return arr.indexOf(val) > -1
            if (!isArrLike(arr)) arr = values(arr)
            return idxOf(arr, val) >= 0
          }
  
          return exports
        })({}))
  
        /* ------------------------------ isBrowser ------------------------------ */
  
        var isBrowser = (_licia.isBrowser = (function (exports) {
          /* Check if running in a browser.
           */
  
          /* example
           * console.log(isBrowser); // -> true if running in a browser
           */
  
          /* typescript
           * export declare const isBrowser: boolean;
           */
  
          exports =
            typeof window === 'object' && typeof document === 'object' && document.nodeType === 9
  
          return exports
        })({}))
  
        /* ------------------------------ isMatch ------------------------------ */
  
        var isMatch = (_licia.isMatch = (function (exports) {
          /* Check if keys and values in src are contained in obj.
           *
           * |Name  |Desc                              |
           * |------|----------------------------------|
           * |obj   |Object to inspect                 |
           * |src   |Object of property values to match|
           * |return|True if object is match           |
           */
  
          /* example
           * isMatch({ a: 1, b: 2 }, { a: 1 }); // -> true
           */
  
          /* typescript
           * export declare function isMatch(obj: any, src: any): boolean;
           */
  
          /* dependencies
           * keys
           */
          exports = function (obj, src) {
            var _keys = keys(src)
            var len = _keys.length
            if (obj == null) return !len
            obj = Object(obj)
            for (var i = 0; i < len; i++) {
              var key = _keys[i]
              if (src[key] !== obj[key] || !(key in obj)) return false
            }
            return true
          }
  
          return exports
        })({}))
  
        /* ------------------------------ matcher ------------------------------ */
  
        var matcher = (_licia.matcher = (function (exports) {
          /* Return a predicate function that checks if attrs are contained in an object.
           *
           * |Name  |Desc                              |
           * |------|----------------------------------|
           * |attrs |Object of property values to match|
           * |return|New predicate function            |
           */
  
          /* example
           * const filter = require('licia/filter');
           *
           * const objects = [
           *     { a: 1, b: 2, c: 3 },
           *     { a: 4, b: 5, c: 6 }
           * ];
           * filter(objects, matcher({ a: 4, c: 6 })); // -> [{a: 4, b: 5, c: 6}]
           */
  
          /* typescript
           * export declare function matcher(attrs: any): types.AnyFn;
           */
  
          /* dependencies
           * extendOwn isMatch types
           */
          exports = function (attrs) {
            attrs = extendOwn({}, attrs)
            return function (obj) {
              return isMatch(obj, attrs)
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ restArgs ------------------------------ */
  
        var restArgs = (_licia.restArgs = (function (exports) {
          /* This accumulates the arguments passed into an array, after a given index.
           *
           * |Name      |Desc                                   |
           * |----------|---------------------------------------|
           * |function  |Function that needs rest parameters    |
           * |startIndex|The start index to accumulates         |
           * |return    |Generated function with rest parameters|
           */
  
          /* example
           * const paramArr = restArgs(function(rest) {
           *     return rest;
           * });
           * paramArr(1, 2, 3, 4); // -> [1, 2, 3, 4]
           */
  
          /* typescript
           * export declare function restArgs(
           *     fn: types.AnyFn,
           *     startIndex?: number
           * ): types.AnyFn;
           */
  
          /* dependencies
           * types
           */
          exports = function (fn, startIdx) {
            startIdx = startIdx == null ? fn.length - 1 : +startIdx
            return function () {
              var len = Math.max(arguments.length - startIdx, 0)
              var rest = new Array(len)
              var i
              for (i = 0; i < len; i++) rest[i] = arguments[i + startIdx]
  
              // Call runs faster than apply.
              switch (startIdx) {
                case 0:
                  return fn.call(this, rest)
                case 1:
                  return fn.call(this, arguments[0], rest)
                case 2:
                  return fn.call(this, arguments[0], arguments[1], rest)
              }
              var args = new Array(startIdx + 1)
              for (i = 0; i < startIdx; i++) args[i] = arguments[i]
              args[startIdx] = rest
              return fn.apply(this, args)
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ mergeArr ------------------------------ */
  
        var mergeArr = (_licia.mergeArr = (function (exports) {
          /* Merge the contents of arrays together into the first array.
           *
           * |Name  |Desc                                |
           * |------|------------------------------------|
           * |first |Array to merge                      |
           * |arrays|Arrays to merge into the first array|
           * |return|First array                         |
           */
  
          /* example
           * const a = [1, 2];
           * mergeArr(a, [3, 4], [5, 6]);
           * console.log(a); // -> [1, 2, 3, 4, 5, 6]
           */
  
          /* typescript
           * export declare function mergeArr<T, U>(
           *     first: ArrayLike<T>,
           *     ...arrays: ArrayLike<U>[]
           * ): ArrayLike<T | U>;
           */
  
          /* dependencies
           * restArgs
           */
          exports = restArgs(function (first, arrays) {
            var end = first.length
            for (var i = 0, len = arrays.length; i < len; i++) {
              var arr = arrays[i]
              for (var j = 0, _len = arr.length; j < _len; j++) {
                first[end++] = arr[j]
              }
            }
            first.length = end
            return first
          })
  
          return exports
        })({}))
  
        /* ------------------------------ upperFirst ------------------------------ */
  
        var upperFirst = (_licia.upperFirst = (function (exports) {
          /* Convert the first character of string to upper case.
           *
           * |Name  |Desc             |
           * |------|-----------------|
           * |str   |String to convert|
           * |return|Converted string |
           */
  
          /* example
           * upperFirst('red'); // -> Red
           */
  
          /* typescript
           * export declare function upperFirst(str: string): string;
           */
  
          exports = function (str) {
            if (str.length < 1) return str
            return str[0].toUpperCase() + str.slice(1)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ prefix ------------------------------ */
  
        var prefix = (_licia.prefix = (function (exports) {
          /* Add vendor prefixes to a CSS attribute.
           *
           * |Name  |Desc                  |
           * |------|----------------------|
           * |name  |Property name         |
           * |return|Prefixed property name|
           *
           * ### dash
           *
           * Create a dasherize version.
           */
  
          /* example
           * prefix('text-emphasis'); // -> 'WebkitTextEmphasis'
           * prefix.dash('text-emphasis'); // -> '-webkit-text-emphasis'
           * prefix('color'); // -> 'color'
           */
  
          /* typescript
           * export declare namespace prefix {
           *     function dash(name: string): string;
           * }
           * export declare function prefix(name: string): string;
           */
  
          /* dependencies
           * memoize camelCase upperFirst has kebabCase
           */
          exports = memoize(function (name) {
            name = name.replace(regPrefixes, '')
            name = camelCase(name)
            if (has(style, name)) return name
            var i = prefixes.length
            while (i--) {
              var prefixName = prefixes[i] + upperFirst(name)
              if (has(style, prefixName)) return prefixName
            }
            return name
          })
          exports.dash = memoize(function (name) {
            var camelCaseResult = exports(name)
            return (regPrefixes.test(camelCaseResult) ? '-' : '') + kebabCase(camelCaseResult)
          })
          var prefixes = ['O', 'ms', 'Moz', 'Webkit']
          var regPrefixes = /^(O)|(ms)|(Moz)|(Webkit)|(-o-)|(-ms-)|(-moz-)|(-webkit-)/g
          var style = document.createElement('p').style
  
          return exports
        })({}))
  
        /* ------------------------------ property ------------------------------ */
  
        var property = (_licia.property = (function (exports) {
          /* Return a function that will itself return the key property of any passed-in object.
           *
           * |Name  |Desc                       |
           * |------|---------------------------|
           * |path  |Path of the property to get|
           * |return|New accessor function      |
           */
  
          /* example
           * const obj = { a: { b: 1 } };
           * property('a')(obj); // -> {b: 1}
           * property(['a', 'b'])(obj); // -> 1
           */
  
          /* typescript
           * export declare function property(path: string | string[]): types.AnyFn;
           */
  
          /* dependencies
           * isArr safeGet types
           */
          exports = function (path) {
            if (!isArr(path)) return shallowProperty(path)
            return function (obj) {
              return safeGet(obj, path)
            }
          }
          function shallowProperty(key) {
            return function (obj) {
              return obj == null ? void 0 : obj[key]
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ safeCb ------------------------------ */
  
        var safeCb = (_licia.safeCb = (function (exports) {
          /* Create callback based on input value.
           */
  
          /* typescript
           * export declare function safeCb(
           *     val?: any,
           *     ctx?: any,
           *     argCount?: number
           * ): types.AnyFn;
           */
  
          /* dependencies
           * isFn isObj isArr optimizeCb matcher identity types property
           */
          exports = function (val, ctx, argCount) {
            if (val == null) return identity
            if (isFn(val)) return optimizeCb(val, ctx, argCount)
            if (isObj(val) && !isArr(val)) return matcher(val)
            return property(val)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ filter ------------------------------ */
  
        var filter = (_licia.filter = (function (exports) {
          /* Iterates over elements of collection, returning an array of all the values that pass a truth test.
           *
           * |Name     |Desc                                   |
           * |---------|---------------------------------------|
           * |obj      |Collection to iterate over             |
           * |predicate|Function invoked per iteration         |
           * |ctx      |Predicate context                      |
           * |return   |Array of all values that pass predicate|
           */
  
          /* example
           * filter([1, 2, 3, 4, 5], function(val) {
           *     return val % 2 === 0;
           * }); // -> [2, 4]
           */
  
          /* typescript
           * export declare function filter<T>(
           *     list: types.List<T>,
           *     iterator: types.ListIterator<T, boolean>,
           *     context?: any
           * ): T[];
           * export declare function filter<T>(
           *     object: types.Dictionary<T>,
           *     iterator: types.ObjectIterator<T, boolean>,
           *     context?: any
           * ): T[];
           */
  
          /* dependencies
           * safeCb each types
           */
          exports = function (obj, predicate, ctx) {
            var ret = []
            predicate = safeCb(predicate, ctx)
            each(obj, function (val, idx, list) {
              if (predicate(val, idx, list)) ret.push(val)
            })
            return ret
          }
  
          return exports
        })({}))
  
        /* ------------------------------ unique ------------------------------ */
  
        var unique = (_licia.unique = (function (exports) {
          /* Create duplicate-free version of an array.
           *
           * |Name  |Desc                         |
           * |------|-----------------------------|
           * |arr   |Array to inspect             |
           * |cmp   |Function for comparing values|
           * |return|New duplicate free array     |
           */
  
          /* example
           * unique([1, 2, 3, 1]); // -> [1, 2, 3]
           */
  
          /* typescript
           * export declare function unique(
           *     arr: any[],
           *     cmp?: (a: any, b: any) => boolean | number
           * ): any[];
           */
  
          /* dependencies
           * filter
           */
          exports = function (arr, cmp) {
            cmp = cmp || isEqual
            return filter(arr, function (item, idx, arr) {
              var len = arr.length
              while (++idx < len) {
                if (cmp(item, arr[idx])) return false
              }
              return true
            })
          }
          function isEqual(a, b) {
            return a === b
          }
  
          return exports
        })({}))
  
        /* ------------------------------ allKeys ------------------------------ */
  
        var allKeys = (_licia.allKeys = (function (exports) {
          /* Retrieve all the names of object's own and inherited properties.
           *
           * |Name   |Desc                       |
           * |-------|---------------------------|
           * |obj    |Object to query            |
           * |options|Options                    |
           * |return |Array of all property names|
           *
           * Available options:
           *
           * |Name              |Desc                     |
           * |------------------|-------------------------|
           * |prototype=true    |Include prototype keys   |
           * |unenumerable=false|Include unenumerable keys|
           * |symbol=false      |Include symbol keys      |
           *
           * Members of Object's prototype won't be retrieved.
           */
  
          /* example
           * const obj = Object.create({ zero: 0 });
           * obj.one = 1;
           * allKeys(obj); // -> ['zero', 'one']
           */
  
          /* typescript
           * export declare namespace allKeys {
           *     interface IOptions {
           *         prototype?: boolean;
           *         unenumerable?: boolean;
           *     }
           * }
           * export declare function allKeys(
           *     obj: any,
           *     options: { symbol: true } & allKeys.IOptions
           * ): Array<string | Symbol>;
           * export declare function allKeys(
           *     obj: any,
           *     options?: ({ symbol: false } & allKeys.IOptions) | allKeys.IOptions
           * ): string[];
           */
  
          /* dependencies
           * keys getProto unique
           */
          var getOwnPropertyNames = Object.getOwnPropertyNames
          var getOwnPropertySymbols = Object.getOwnPropertySymbols
          exports = function (obj) {
            var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
              _ref$prototype = _ref.prototype,
              prototype = _ref$prototype === void 0 ? true : _ref$prototype,
              _ref$unenumerable = _ref.unenumerable,
              unenumerable = _ref$unenumerable === void 0 ? false : _ref$unenumerable,
              _ref$symbol = _ref.symbol,
              symbol = _ref$symbol === void 0 ? false : _ref$symbol
            var ret = []
            if ((unenumerable || symbol) && getOwnPropertyNames) {
              var getKeys = keys
              if (unenumerable && getOwnPropertyNames) getKeys = getOwnPropertyNames
              do {
                ret = ret.concat(getKeys(obj))
                if (symbol && getOwnPropertySymbols) {
                  ret = ret.concat(getOwnPropertySymbols(obj))
                }
              } while (prototype && (obj = getProto(obj)) && obj !== Object.prototype)
              ret = unique(ret)
            } else {
              if (prototype) {
                for (var key in obj) ret.push(key)
              } else {
                ret = keys(obj)
              }
            }
            return ret
          }
  
          return exports
        })({}))
  
        /* ------------------------------ defaults ------------------------------ */
        _licia.defaults = (function (exports) {
          /* Fill in undefined properties in object with the first value present in the following list of defaults objects.
           *
           * |Name  |Desc              |
           * |------|------------------|
           * |obj   |Destination object|
           * |...src|Sources objects   |
           * |return|Destination object|
           */
  
          /* example
           * defaults({ name: 'RedHood' }, { name: 'Unknown', age: 24 }); // -> {name: 'RedHood', age: 24}
           */
  
          /* typescript
           * export declare function defaults(obj: any, ...src: any[]): any;
           */
  
          /* dependencies
           * createAssigner allKeys
           */
          exports = createAssigner(allKeys, true)
  
          return exports
        })({})
  
        /* ------------------------------ extend ------------------------------ */
  
        var extend = (_licia.extend = (function (exports) {
          /* Copy all of the properties in the source objects over to the destination object.
           *
           * |Name       |Desc              |
           * |-----------|------------------|
           * |destination|Destination object|
           * |...sources |Sources objects   |
           * |return     |Destination object|
           */
  
          /* example
           * extend({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}
           */
  
          /* typescript
           * export declare function extend(destination: any, ...sources: any[]): any;
           */
  
          /* dependencies
           * createAssigner allKeys
           */
          exports = createAssigner(allKeys)
  
          return exports
        })({}))
  
        /* ------------------------------ map ------------------------------ */
  
        var map = (_licia.map = (function (exports) {
          /* Create an array of values by running each element in collection through iteratee.
           *
           * |Name    |Desc                          |
           * |--------|------------------------------|
           * |object  |Collection to iterate over    |
           * |iterator|Function invoked per iteration|
           * |context |Function context              |
           * |return  |New mapped array              |
           */
  
          /* example
           * map([4, 8], function(n) {
           *     return n * n;
           * }); // -> [16, 64]
           */
  
          /* typescript
           * export declare function map<T, TResult>(
           *     list: types.List<T>,
           *     iterator: types.ListIterator<T, TResult>,
           *     context?: any
           * ): TResult[];
           * export declare function map<T, TResult>(
           *     object: types.Dictionary<T>,
           *     iterator: types.ObjectIterator<T, TResult>,
           *     context?: any
           * ): TResult[];
           */
  
          /* dependencies
           * safeCb keys isArrLike types
           */
          exports = function (obj, iterator, ctx) {
            iterator = safeCb(iterator, ctx)
            var _keys = !isArrLike(obj) && keys(obj)
            var len = (_keys || obj).length
            var results = Array(len)
            for (var i = 0; i < len; i++) {
              var curKey = _keys ? _keys[i] : i
              results[i] = iterator(obj[curKey], curKey, obj)
            }
            return results
          }
  
          return exports
        })({}))
  
        /* ------------------------------ toArr ------------------------------ */
  
        var toArr = (_licia.toArr = (function (exports) {
          /* Convert value to an array.
           *
           * |Name  |Desc            |
           * |------|----------------|
           * |val   |Value to convert|
           * |return|Converted array |
           */
  
          /* example
           * toArr({ a: 1, b: 2 }); // -> [{a: 1, b: 2}]
           * toArr('abc'); // -> ['abc']
           * toArr(1); // -> [1]
           * toArr(null); // -> []
           */
  
          /* typescript
           * export declare function toArr(val: any): any[];
           */
  
          /* dependencies
           * isArrLike map isArr isStr
           */
          exports = function (val) {
            if (!val) return []
            if (isArr(val)) return val
            if (isArrLike(val) && !isStr(val)) return map(val)
            return [val]
          }
  
          return exports
        })({}))
  
        /* ------------------------------ Class ------------------------------ */
  
        var Class = (_licia.Class = (function (exports) {
          /* Create JavaScript class.
           *
           * |Name   |Desc                             |
           * |-------|---------------------------------|
           * |methods|Public methods                   |
           * [statics|Static methods                   |
           * |return |Function used to create instances|
           */
  
          /* example
           * const People = Class({
           *     initialize: function People(name, age) {
           *         this.name = name;
           *         this.age = age;
           *     },
           *     introduce: function() {
           *         return 'I am ' + this.name + ', ' + this.age + ' years old.';
           *     }
           * });
           *
           * const Student = People.extend(
           *     {
           *         initialize: function Student(name, age, school) {
           *             this.callSuper(People, 'initialize', arguments);
           *
           *             this.school = school;
           *         },
           *         introduce: function() {
           *             return (
           *                 this.callSuper(People, 'introduce') +
           *                 '\n I study at ' +
           *                 this.school +
           *                 '.'
           *             );
           *         }
           *     },
           *     {
           *         is: function(obj) {
           *             return obj instanceof Student;
           *         }
           *     }
           * );
           *
           * const a = new Student('allen', 17, 'Hogwarts');
           * a.introduce(); // -> 'I am allen, 17 years old. \n I study at Hogwarts.'
           * Student.is(a); // -> true
           */
  
          /* typescript
           * export declare namespace Class {
           *     class Base {
           *         toString(): string;
           *     }
           *     class IConstructor extends Base {
           *         constructor(...args: any[]);
           *         static extend(methods: any, statics: any): IConstructor;
           *         static inherits(Class: types.AnyFn): void;
           *         static methods(methods: any): IConstructor;
           *         static statics(statics: any): IConstructor;
           *         [method: string]: any;
           *     }
           * }
           * export declare function Class(methods: any, statics?: any): Class.IConstructor;
           */
  
          /* dependencies
           * extend toArr inherits safeGet isMiniProgram types
           */
          exports = function (methods, statics) {
            return Base.extend(methods, statics)
          }
          function makeClass(parent, methods, statics) {
            statics = statics || {}
            var className = methods.className || safeGet(methods, 'initialize.name') || ''
            delete methods.className
            var ctor = function () {
              var args = toArr(arguments)
              return this.initialize ? this.initialize.apply(this, args) || this : this
            }
            if (!isMiniProgram) {
              // unsafe-eval CSP violation
              try {
                ctor = new Function(
                  'toArr',
                  'return function ' +
                    className +
                    '()' +
                    '{' +
                    'var args = toArr(arguments);' +
                    'return this.initialize ? this.initialize.apply(this, args) || this : this;' +
                    '};'
                )(toArr)
              } catch (e) {
                /* eslint-disable no-empty */
              }
            }
            inherits(ctor, parent)
            ctor.prototype.constructor = ctor
            ctor.extend = function (methods, statics) {
              return makeClass(ctor, methods, statics)
            }
            ctor.inherits = function (Class) {
              inherits(ctor, Class)
            }
            ctor.methods = function (methods) {
              extend(ctor.prototype, methods)
              return ctor
            }
            ctor.statics = function (statics) {
              extend(ctor, statics)
              return ctor
            }
            ctor.methods(methods).statics(statics)
            return ctor
          }
          var Base = (exports.Base = makeClass(Object, {
            className: 'Base',
            callSuper: function (parent, name, args) {
              var superMethod = parent.prototype[name]
              return superMethod.apply(this, args)
            },
            toString: function () {
              return this.constructor.name
            },
          }))
  
          return exports
        })({}))
  
        /* ------------------------------ Select ------------------------------ */
  
        var Select = (_licia.Select = (function (exports) {
          /* Simple wrapper of querySelectorAll to make dom selection easier.
           *
           * ### constructor
           *
           * |Name    |Desc               |
           * |--------|-------------------|
           * |selector|Dom selector string|
           *
           * ### find
           *
           * Get desdendants of current matched elements.
           *
           * |Name    |Desc               |
           * |--------|-------------------|
           * |selector|Dom selector string|
           *
           * ### each
           *
           * Iterate over matched elements.
           *
           * |Name|Desc                                |
           * |----|------------------------------------|
           * |fn  |Function to execute for each element|
           */
  
          /* example
           * const $test = new Select('#test');
           * $test.find('.test').each(function(idx, element) {
           *     // Manipulate dom nodes
           * });
           */
  
          /* typescript
           * export declare class Select {
           *     constructor(selector: string | Element | Document);
           *     find(selector: string): Select;
           *     each(fn: types.AnyFn): Select;
           * }
           */
  
          /* dependencies
           * Class isStr each types mergeArr
           */
          exports = Class({
            className: 'Select',
            initialize: function (selector) {
              this.length = 0
              if (!selector) return this
              if (isStr(selector)) return rootSelect.find(selector)
              if (selector.nodeType) {
                this[0] = selector
                this.length = 1
              }
            },
            find: function (selector) {
              var ret = new exports()
              this.each(function () {
                mergeArr(ret, this.querySelectorAll(selector))
              })
              return ret
            },
            each: function (fn) {
              each(this, function (element, idx) {
                fn.call(element, idx, element)
              })
              return this
            },
          })
          var rootSelect = new exports(document)
  
          return exports
        })({}))
  
        /* ------------------------------ $safeEls ------------------------------ */
  
        var $safeEls = (_licia.$safeEls = (function (exports) {
          /* Convert value into an array, if it's a string, do querySelector.
           *
           * |Name  |Desc             |
           * |------|-----------------|
           * |val   |Value to convert |
           * |return|Array of elements|
           */
  
          /* example
           * $safeEls(document.querySelector('.test'));
           * $safeEls(document.querySelectorAll('.test'));
           * $safeEls('.test'); // -> Array of elements with test class
           */
  
          /* typescript
           * export declare namespace $safeEls {
           *     type El = Element | Element[] | NodeListOf<Element> | string;
           * }
           * export declare function $safeEls(val: $safeEls.El): Element[];
           */
  
          /* dependencies
           * isStr toArr Select
           */
          exports = function (val) {
            return toArr(isStr(val) ? new Select(val) : val)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $attr ------------------------------ */
  
        var $attr = (_licia.$attr = (function (exports) {
          /* Element attribute manipulation.
           *
           * Get the value of an attribute for the first element in the set of matched elements.
           *
           * |Name   |Desc                            |
           * |-------|--------------------------------|
           * |element|Elements to manipulate          |
           * |name   |Attribute name                  |
           * |return |Attribute value of first element|
           *
           * Set one or more attributes for the set of matched elements.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |name   |Attribute name        |
           * |val    |Attribute value       |
           *
           * |Name      |Desc                                  |
           * |----------|--------------------------------------|
           * |element   |Elements to manipulate                |
           * |attributes|Object of attribute-value pairs to set|
           *
           * ### remove
           *
           * Remove an attribute from each element in the set of matched elements.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |name   |Attribute name        |
           */
  
          /* example
           * $attr('#test', 'attr1', 'test');
           * $attr('#test', 'attr1'); // -> test
           * $attr.remove('#test', 'attr1');
           * $attr('#test', {
           *     attr1: 'test',
           *     attr2: 'test'
           * });
           */
  
          /* typescript
           * export declare namespace $attr {
           *     function remove(element: $safeEls.El, name: string): void;
           * }
           * export declare function $attr(
           *     element: $safeEls.El,
           *     name: string,
           *     value: string
           * ): void;
           * export declare function $attr(
           *     element: $safeEls.El,
           *     attributes: types.PlainObj<string>
           * ): void;
           * export declare function $attr(element: $safeEls.El, name: string): string;
           */
  
          /* dependencies
           * toArr isObj isStr each isUndef $safeEls types
           */
          exports = function (els, name, val) {
            els = $safeEls(els)
            var isGetter = isUndef(val) && isStr(name)
            if (isGetter) return getAttr(els[0], name)
            var attrs = name
            if (!isObj(attrs)) {
              attrs = {}
              attrs[name] = val
            }
            setAttr(els, attrs)
          }
          exports.remove = function (els, names) {
            els = $safeEls(els)
            names = toArr(names)
            each(els, function (node) {
              each(names, function (name) {
                node.removeAttribute(name)
              })
            })
          }
          function getAttr(el, name) {
            return el.getAttribute(name)
          }
          function setAttr(els, attrs) {
            each(els, function (el) {
              each(attrs, function (val, name) {
                el.setAttribute(name, val)
              })
            })
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $css ------------------------------ */
  
        var $css = (_licia.$css = (function (exports) {
          /* Element css manipulation.
           *
           * Get the computed style properties for the first element in the set of matched elements.
           *
           * |Name   |Desc                      |
           * |-------|--------------------------|
           * |element|Elements to manipulate    |
           * |name   |Property name             |
           * |return |Css value of first element|
           *
           * Set one or more CSS properties for the set of matched elements.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |name   |Property name         |
           * |val    |Css value             |
           *
           * |Name      |Desc                            |
           * |----------|--------------------------------|
           * |element   |Elements to manipulate          |
           * |properties|Object of css-value pairs to set|
           */
  
          /* example
           * $css('#test', {
           *     color: '#fff',
           *     background: 'black',
           *     opacity: 0.5
           * });
           * $css('#test', 'display', 'block');
           * $css('#test', 'color'); // -> #fff
           */
  
          /* typescript
           * export declare function $css(element: $safeEls.El, name: string): string;
           * export declare function $css(
           *     element: $safeEls.El,
           *     name: string,
           *     val: string
           * ): void;
           * export declare function $css(
           *     element: $safeEls.El,
           *     properties: types.PlainObj<string | number>
           * ): void;
           */
  
          /* dependencies
           * isStr isObj kebabCase isUndef contain isNum $safeEls prefix each types
           */
          exports = function (nodes, name, val) {
            nodes = $safeEls(nodes)
            var isGetter = isUndef(val) && isStr(name)
            if (isGetter) return getCss(nodes[0], name)
            var css = name
            if (!isObj(css)) {
              css = {}
              css[name] = val
            }
            setCss(nodes, css)
          }
          function getCss(node, name) {
            return node.style[prefix(name)] || getComputedStyle(node, '').getPropertyValue(name)
          }
          function setCss(nodes, css) {
            each(nodes, function (node) {
              var cssText = ';'
              each(css, function (val, key) {
                key = prefix.dash(key)
                cssText += key + ':' + addPx(key, val) + ';'
              })
              node.style.cssText += cssText
            })
          }
          var cssNumProps = [
            'column-count',
            'columns',
            'font-weight',
            'line-weight',
            'opacity',
            'z-index',
            'zoom',
          ]
          function addPx(key, val) {
            var needPx = isNum(val) && !contain(cssNumProps, kebabCase(key))
            return needPx ? val + 'px' : val
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $data ------------------------------ */
  
        var $data = (_licia.$data = (function (exports) {
          /* Wrapper of $attr, adds data- prefix to keys.
           */
  
          /* example
           * $data('#test', 'attr1', 'eustia');
           */
  
          /* typescript
           * export declare function $data(
           *     element: $safeEls.El,
           *     name: string,
           *     value: string
           * ): void;
           * export declare function $data(
           *     element: $safeEls.El,
           *     attributes: types.PlainObj<string>
           * ): void;
           * export declare function $data(element: $safeEls.El, name: string): string;
           */
  
          /* eslint-disable no-unused-vars */
  
          /* dependencies
           * $attr isStr isObj each $safeEls types
           */
          exports = function (nodes, name, val) {
            var dataName = name
            if (isStr(name)) dataName = 'data-' + name
            if (isObj(name)) {
              dataName = {}
              each(name, function (val, key) {
                dataName['data-' + key] = val
              })
            }
            return $attr(nodes, dataName, val)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $insert ------------------------------ */
  
        var $insert = (_licia.$insert = (function (exports) {
          /* Insert html on different position.
           *
           * ### before
           *
           * Insert content before elements.
           *
           * ### after
           *
           * Insert content after elements.
           *
           * ### prepend
           *
           * Insert content to the beginning of elements.
           *
           * ### append
           *
           * Insert content to the end of elements.
           *
           * |Name   |Desc                   |
           * |-------|-----------------------|
           * |element|Elements to manipulate |
           * |content|Html strings or element|
           */
  
          /* example
           * // <div id="test"><div class="mark"></div></div>
           * $insert.before('#test', '<div>licia</div>');
           * // -> <div>licia</div><div id="test"><div class="mark"></div></div>
           * $insert.after('#test', '<div>licia</div>');
           * // -> <div id="test"><div class="mark"></div></div><div>licia</div>
           * $insert.prepend('#test', '<div>licia</div>');
           * // -> <div id="test"><div>licia</div><div class="mark"></div></div>
           * $insert.append('#test', '<div>licia</div>');
           * // -> <div id="test"><div class="mark"></div><div>licia</div></div>
           */
  
          /* typescript
           * export declare namespace $insert {
           *     type IInsert = (element: $safeEls.El, content: string | Element) => void;
           * }
           * export declare const $insert: {
           *     before: $insert.IInsert;
           *     after: $insert.IInsert;
           *     append: $insert.IInsert;
           *     prepend: $insert.IInsert;
           * };
           */
  
          /* dependencies
           * each $safeEls isStr
           */
          exports = {
            before: insertFactory('beforebegin'),
            after: insertFactory('afterend'),
            append: insertFactory('beforeend'),
            prepend: insertFactory('afterbegin'),
          }
          function insertFactory(type) {
            return function (nodes, val) {
              nodes = $safeEls(nodes)
              each(nodes, function (node) {
                if (isStr(val)) {
                  node.insertAdjacentHTML(type, val)
                } else {
                  var parentNode = node.parentNode
                  switch (type) {
                    case 'beforebegin':
                      if (parentNode) {
                        parentNode.insertBefore(val, node)
                      }
                      break
                    case 'afterend':
                      if (parentNode) {
                        parentNode.insertBefore(val, node.nextSibling)
                      }
                      break
                    case 'beforeend':
                      node.appendChild(val)
                      break
                    case 'afterbegin':
                      node.prepend(val)
                      break
                  }
                }
              })
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $offset ------------------------------ */
  
        var $offset = (_licia.$offset = (function (exports) {
          /* Get the position of the element in document.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to get offset|
           * |return |Element position      |
           */
  
          /* example
           * $offset('#test'); // -> {left: 0, top: 0, width: 0, height: 0}
           */
  
          /* typescript
           * export declare namespace $offset {
           *     interface IOffset {
           *         left: number;
           *         top: number;
           *         width: number;
           *         height: number;
           *     }
           * }
           * export declare function $offset(element: $safeEls.El): $offset.IOffset;
           */
  
          /* dependencies
           * $safeEls
           */
          exports = function (els) {
            els = $safeEls(els)
            var el = els[0]
            var clientRect = el.getBoundingClientRect()
            return {
              left: clientRect.left + window.pageXOffset,
              top: clientRect.top + window.pageYOffset,
              width: Math.round(clientRect.width),
              height: Math.round(clientRect.height),
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $property ------------------------------ */
  
        var $property = (_licia.$property = (function (exports) {
          /* Element property html, text, val getter and setter.
           *
           * ### html
           *
           * Get the HTML contents of the first element in the set of matched elements or
           * set the HTML contents of every matched element.
           *
           * ### text
           *
           * Get the combined text contents of each element in the set of matched
           * elements, including their descendants, or set the text contents of the
           * matched elements.
           *
           * ### val
           *
           * Get the current value of the first element in the set of matched elements or
           * set the value of every matched element.
           */
  
          /* example
           * $property.html('#test', 'licia');
           * $property.html('#test'); // -> licia
           */
  
          /* typescript
           * export declare namespace $property {
           *     interface IProperty {
           *         (element: $safeEls.El, value: string): void;
           *         (element: $safeEls.El): string;
           *     }
           * }
           * export declare const $property: {
           *     html: $property.IProperty;
           *     val: $property.IProperty;
           *     text: $property.IProperty;
           * };
           */
  
          /* dependencies
           * isUndef each $safeEls
           */
          exports = {
            html: propFactory('innerHTML'),
            text: propFactory('textContent'),
            val: propFactory('value'),
          }
          function propFactory(name) {
            return function (nodes, val) {
              nodes = $safeEls(nodes)
              var node = nodes[0]
              if (isUndef(val)) {
                return node ? node[name] : ''
              }
              if (!node) return
              each(nodes, function (node) {
                node[name] = val
              })
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $remove ------------------------------ */
  
        var $remove = (_licia.$remove = (function (exports) {
          /* Remove the set of matched elements from the DOM.
           *
           * |Name   |Desc              |
           * |-------|------------------|
           * |element|Elements to delete|
           */
  
          /* example
           * $remove('#test');
           */
  
          /* typescript
           * export declare function $remove(element: $safeEls.El);
           */
  
          /* dependencies
           * each $safeEls
           */
          exports = function (els) {
            els = $safeEls(els)
            each(els, function (el) {
              var parent = el.parentNode
              if (parent) parent.removeChild(el)
            })
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $show ------------------------------ */
  
        var $show = (_licia.$show = (function (exports) {
          /* Show elements.
           *
           * |Name   |Desc            |
           * |-------|----------------|
           * |element|Elements to show|
           */
  
          /* example
           * $show('#test');
           */
  
          /* typescript
           * export declare function $show(element: $safeEls.El): void;
           */
  
          /* dependencies
           * each $safeEls
           */
          exports = function (els) {
            els = $safeEls(els)
            each(els, function (el) {
              if (isHidden(el)) {
                el.style.display = getDefDisplay(el.nodeName)
              }
            })
          }
          function isHidden(el) {
            return getComputedStyle(el, '').getPropertyValue('display') == 'none'
          }
          var elDisplay = {}
          function getDefDisplay(elName) {
            var el, display
            if (!elDisplay[elName]) {
              el = document.createElement(elName)
              document.documentElement.appendChild(el)
              display = getComputedStyle(el, '').getPropertyValue('display')
              el.parentNode.removeChild(el)
              display == 'none' && (display = 'block')
              elDisplay[elName] = display
            }
            return elDisplay[elName]
          }
  
          return exports
        })({}))
  
        /* ------------------------------ delegate ------------------------------ */
  
        var delegate = (_licia.delegate = (function (exports) {
          /* Event delegation.
           *
           * ### add
           *
           * Add event delegation.
           *
           * |Name    |Desc          |
           * |--------|--------------|
           * |el      |Parent element|
           * |type    |Event type    |
           * |selector|Match selector|
           * |cb      |Event callback|
           *
           * ### remove
           *
           * Remove event delegation.
           */
  
          /* example
           * const container = document.getElementById('container');
           * function clickHandler() {
           *     // Do something...
           * }
           * delegate.add(container, 'click', '.children', clickHandler);
           * delegate.remove(container, 'click', '.children', clickHandler);
           */
  
          /* typescript
           * export declare const delegate: {
           *     add(el: Element, type: string, selector: string, cb: types.AnyFn): void;
           *     remove(el: Element, type: string, selector: string, cb: types.AnyFn): void;
           * };
           */
  
          /* dependencies
           * Class contain types
           */
          function retTrue() {
            return true
          }
          function retFalse() {
            return false
          }
          function trigger(e) {
            var handlers = this.events[e.type]
            var handler
            var handlerQueue = formatHandlers.call(this, e, handlers)
            e = new exports.Event(e)
            var i = 0,
              j,
              matched,
              ret
            while ((matched = handlerQueue[i++]) && !e.isPropagationStopped()) {
              e.curTarget = matched.el
              j = 0
              while ((handler = matched.handlers[j++]) && !e.isImmediatePropagationStopped()) {
                ret = handler.handler.apply(matched.el, [e])
                if (ret === false) {
                  e.preventDefault()
                  e.stopPropagation()
                }
              }
            }
          }
          function formatHandlers(e, handlers) {
            var current = e.target
            var ret = []
            var delegateCount = handlers.delegateCount
            var selector
            var matches
            var handler
            var i
            if (current.nodeType) {
              for (; current !== this; current = current.parentNode || this) {
                matches = []
                for (i = 0; i < delegateCount; i++) {
                  handler = handlers[i]
                  selector = handler.selector + ' '
                  if (matches[selector] === undefined) {
                    matches[selector] = contain(this.querySelectorAll(selector), current)
                  }
                  if (matches[selector]) matches.push(handler)
                }
                if (matches.length)
                  ret.push({
                    el: current,
                    handlers: matches,
                  })
              }
            }
            if (delegateCount < handlers.length) {
              ret.push({
                el: this,
                handlers: handlers.slice(delegateCount),
              })
            }
            return ret
          }
          exports = {
            add: function (el, type, selector, fn) {
              var handler = {
                selector: selector,
                handler: fn,
              }
              var handlers
              if (!el.events) el.events = {}
              if (!(handlers = el.events[type])) {
                handlers = el.events[type] = []
                handlers.delegateCount = 0
                el.addEventListener(
                  type,
                  function () {
                    trigger.apply(el, arguments)
                  },
                  false
                )
              }
              selector
                ? handlers.splice(handlers.delegateCount++, 0, handler)
                : handlers.push(handler)
            },
            remove: function (el, type, selector, fn) {
              var events = el.events
              if (!events || !events[type]) return
              var handlers = events[type]
              var i = handlers.length
              var handler
              while (i--) {
                handler = handlers[i]
                if ((!selector || handler.selector == selector) && handler.handler == fn) {
                  handlers.splice(i, 1)
                  if (handler.selector) {
                    handlers.delegateCount--
                  }
                }
              }
            },
            Event: Class({
              className: 'Event',
              initialize: function Event(e) {
                this.origEvent = e
              },
              isDefaultPrevented: retFalse,
              isPropagationStopped: retFalse,
              isImmediatePropagationStopped: retFalse,
              preventDefault: function () {
                var e = this.origEvent
                this.isDefaultPrevented = retTrue
                if (e && e.preventDefault) e.preventDefault()
              },
              stopPropagation: function () {
                var e = this.origEvent
                this.isPropagationStopped = retTrue
                if (e && e.stopPropagation) e.stopPropagation()
              },
              stopImmediatePropagation: function () {
                var e = this.origEvent
                this.isImmediatePropagationStopped = retTrue
                if (e && e.stopImmediatePropagation) e.stopImmediatePropagation()
                this.stopPropagation()
              },
            }),
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $event ------------------------------ */
  
        var $event = (_licia.$event = (function (exports) {
          /* bind events to certain dom elements.
           */
  
          /* example
           * function clickHandler() {
           *     // Do something...
           * }
           * $event.on('#test', 'click', clickHandler);
           * $event.off('#test', 'click', clickHandler);
           */
  
          /* typescript
           * export declare const $event: {
           *     on(
           *         element: $safeEls.El,
           *         event: string,
           *         selector: string,
           *         handler: types.AnyFn
           *     ): void;
           *     on(element: $safeEls.El, event: string, handler: types.AnyFn): void;
           *     off(
           *         element: $safeEls.El,
           *         event: string,
           *         selector: string,
           *         handler: types.AnyFn
           *     ): void;
           *     off(element: $safeEls.El, event: string, handler: types.AnyFn): void;
           * };
           */
  
          /* dependencies
           * delegate isUndef $safeEls each types
           */
          exports = {
            on: eventFactory('add'),
            off: eventFactory('remove'),
          }
          function eventFactory(type) {
            return function (nodes, event, selector, handler) {
              nodes = $safeEls(nodes)
              if (isUndef(handler)) {
                handler = selector
                selector = undefined
              }
              each(nodes, function (node) {
                delegate[type](node, event, selector, handler)
              })
            }
          }
  
          return exports
        })({}))
  
        /* ------------------------------ some ------------------------------ */
  
        var some = (_licia.some = (function (exports) {
          /* Check if predicate return truthy for any element.
           *
           * |Name     |Desc                                          |
           * |---------|----------------------------------------------|
           * |obj      |Collection to iterate over                    |
           * |predicate|Function to invoked per iteration             |
           * |ctx      |Predicate context                             |
           * |return   |True if any element passes the predicate check|
           */
  
          /* example
           * some([2, 5], function(val) {
           *     return val % 2 === 0;
           * }); // -> true
           */
  
          /* typescript
           * export declare function some<T>(
           *     list: types.List<T>,
           *     iterator?: types.ListIterator<T, boolean>,
           *     context?: any
           * ): boolean;
           * export declare function some<T>(
           *     object: types.Dictionary<T>,
           *     iterator?: types.ObjectIterator<T, boolean>,
           *     context?: any
           * ): boolean;
           */
  
          /* dependencies
           * safeCb isArrLike keys types
           */
          exports = function (obj, predicate, ctx) {
            predicate = safeCb(predicate, ctx)
            var _keys = !isArrLike(obj) && keys(obj)
            var len = (_keys || obj).length
            for (var i = 0; i < len; i++) {
              var key = _keys ? _keys[i] : i
              if (predicate(obj[key], key, obj)) return true
            }
            return false
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $class ------------------------------ */
  
        var $class = (_licia.$class = (function (exports) {
          /* Element class manipulations.
           *
           * ### add
           *
           * Add the specified class(es) to each element in the set of matched elements.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |names  |Classes to add        |
           *
           * ### has
           *
           * Determine whether any of the matched elements are assigned the given class.
           *
           * |Name   |Desc                                 |
           * |-------|-------------------------------------|
           * |element|Elements to manipulate               |
           * |name   |Class name                           |
           * |return |True if elements has given class name|
           *
           * ### toggle
           *
           * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |name   |Class name to toggle  |
           *
           * ### remove
           *
           * Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
           *
           * |Name   |Desc                  |
           * |-------|----------------------|
           * |element|Elements to manipulate|
           * |name   |Class names to remove |
           */
  
          /* example
           * $class.add('#test', 'class1');
           * $class.add('#test', ['class1', 'class2']);
           * $class.has('#test', 'class1'); // -> true
           * $class.remove('#test', 'class1');
           * $class.has('#test', 'class1'); // -> false
           * $class.toggle('#test', 'class1');
           * $class.has('#test', 'class1'); // -> true
           */
  
          /* typescript
           * export declare const $class: {
           *     add(element: $safeEls.El, name: string | string[]): void;
           *     has(element: $safeEls.El, name: string): boolean;
           *     toggle(element: $safeEls.El, name: string): void;
           *     remove(element: $safeEls.El, name: string): void;
           * };
           */
  
          /* dependencies
           * toArr some $safeEls isStr each
           */
          exports = {
            add: function (els, name) {
              els = $safeEls(els)
              var names = safeName(name)
              each(els, function (el) {
                var classList = []
                each(names, function (name) {
                  if (!exports.has(el, name)) classList.push(name)
                })
                if (classList.length !== 0) {
                  el.className += (el.className ? ' ' : '') + classList.join(' ')
                }
              })
            },
            has: function (els, name) {
              els = $safeEls(els)
              var regName = new RegExp('(^|\\s)' + name + '(\\s|$)')
              return some(els, function (el) {
                return regName.test(el.className)
              })
            },
            toggle: function (els, name) {
              els = $safeEls(els)
              each(els, function (el) {
                if (!exports.has(el, name)) return exports.add(el, name)
                exports.remove(el, name)
              })
            },
            remove: function (els, name) {
              els = $safeEls(els)
              var names = safeName(name)
              each(els, function (el) {
                each(names, function (name) {
                  el.classList.remove(name)
                })
              })
            },
          }
          function safeName(name) {
            return isStr(name) ? name.split(/\s+/) : toArr(name)
          }
  
          return exports
        })({}))
  
        /* ------------------------------ $ ------------------------------ */
        _licia.$ = (function (exports) {
          /* jQuery like style dom manipulator.
           *
           * ### Available methods
           *
           * offset, hide, show, first, last, get, eq, on, off, html, text, val, css, attr,
           * data, rmAttr, remove, addClass, rmClass, toggleClass, hasClass, append, prepend,
           * before, after
           */
  
          /* example
           * const $btn = $('#btn');
           * $btn.html('eustia');
           * $btn.addClass('btn');
           * $btn.show();
           * $btn.on('click', function() {
           *     // Do something...
           * });
           */
  
          /* typescript
           * export declare namespace $ {
           *     class $ extends Select {
           *         find(selector: string): $;
           *         each(fn: types.AnyFn): $;
           *         offset(): $offset.IOffset;
           *         hide(): $;
           *         show(): $;
           *         first(): $;
           *         last(): $;
           *         get(index: number): Element;
           *         eq(index: number): $;
           *         on(event: string, selector: string, handler: types.AnyFn): $;
           *         on(event: string, handler: types.AnyFn): $;
           *         off(event: string, selector: string, handler: types.AnyFn): $;
           *         off(event: string, handler: types.AnyFn): $;
           *         html(): string;
           *         html(value: string): $;
           *         text(): string;
           *         text(value: string): $;
           *         val(): string;
           *         val(value: string): $;
           *         css(name: string): string;
           *         css(name: string, value: string): $;
           *         css(properties: types.PlainObj<string | number>): $;
           *         attr(name: string): string;
           *         attr(name: string, value: string): $;
           *         attr(attributes: types.PlainObj<string>): $;
           *         data(name: string): string;
           *         data(name: string, value: string): $;
           *         data(attributes: types.PlainObj<string>): $;
           *         rmAttr(name: string): $;
           *         remove(): $;
           *         addClass(name: string | string[]): $;
           *         rmClass(name: string): $;
           *         toggleClass(name: string): $;
           *         hasClass(name: string): boolean;
           *         parent(): $;
           *         append(content: string | Element): $;
           *         prepend(content: string | Element): $;
           *         before(content: string | Element): $;
           *         after(content: string | Element): $;
           *     }
           * }
           * declare function $(selector: string | Element | Document): $.$;
           */
  
          /* dependencies
           * Select $offset $show $css $attr $property last $remove $data $event $class $insert isUndef isStr types
           */
          exports = function (selector) {
            return new Select(selector)
          }
          Select.methods({
            offset: function () {
              return $offset(this)
            },
            hide: function () {
              return this.css('display', 'none')
            },
            show: function () {
              $show(this)
              return this
            },
            first: function () {
              return exports(this[0])
            },
            last: function () {
              return exports(last(this))
            },
            get: function (idx) {
              return this[idx]
            },
            eq: function (idx) {
              return exports(this[idx])
            },
            on: function (event, selector, handler) {
              $event.on(this, event, selector, handler)
              return this
            },
            off: function (event, selector, handler) {
              $event.off(this, event, selector, handler)
              return this
            },
            html: function (val) {
              var result = $property.html(this, val)
              if (isUndef(val)) return result
              return this
            },
            text: function (val) {
              var result = $property.text(this, val)
              if (isUndef(val)) return result
              return this
            },
            val: function (val) {
              var result = $property.val(this, val)
              if (isUndef(val)) return result
              return this
            },
            css: function (name, val) {
              var result = $css(this, name, val)
              if (isGetter(name, val)) return result
              return this
            },
            attr: function (name, val) {
              var result = $attr(this, name, val)
              if (isGetter(name, val)) return result
              return this
            },
            data: function (name, val) {
              var result = $data(this, name, val)
              if (isGetter(name, val)) return result
              return this
            },
            rmAttr: function (name) {
              $attr.remove(this, name)
              return this
            },
            remove: function () {
              $remove(this)
              return this
            },
            addClass: function (name) {
              $class.add(this, name)
              return this
            },
            rmClass: function (name) {
              $class.remove(this, name)
              return this
            },
            toggleClass: function (name) {
              $class.toggle(this, name)
              return this
            },
            hasClass: function (name) {
              return $class.has(this, name)
            },
            parent: function () {
              return exports(this[0].parentNode)
            },
            append: function (val) {
              $insert.append(this, val)
              return this
            },
            prepend: function (val) {
              $insert.prepend(this, val)
              return this
            },
            before: function (val) {
              $insert.before(this, val)
              return this
            },
            after: function (val) {
              $insert.after(this, val)
              return this
            },
          })
          var isGetter = function (name, val) {
            return isUndef(val) && isStr(name)
          }
  
          return exports
        })({})
  
        /* ------------------------------ h ------------------------------ */
        _licia.h = (function (exports) {
          /* Create html with JavaScript.
           *
           * |Name    |Desc           |
           * |--------|---------------|
           * |tag     |Tag name       |
           * |attrs   |Attributes     |
           * |...child|Children       |
           * |return  |Created element|
           */
  
          /* example
           * const el = h(
           *     'div#test.title',
           *     {
           *         onclick: function() {},
           *         title: 'test'
           *     },
           *     'inner text'
           * );
           * document.body.appendChild(el);
           */
  
          /* typescript
           * export declare function h(
           *     tag: string,
           *     attrs?: types.PlainObj<any>,
           *     ...child: Array<string | HTMLElement>
           * ): HTMLElement;
           */
  
          /* dependencies
           * isEl isStr startWith $class $css each isFn types
           */
          exports = function (tag, attrs) {
            for (
              var _len = arguments.length, children = new Array(_len > 2 ? _len - 2 : 0), _key = 2;
              _key < _len;
              _key++
            ) {
              children[_key - 2] = arguments[_key]
            }
            if (isEl(attrs) || isStr(attrs)) {
              children.unshift(attrs)
              attrs = null
            }
            if (!attrs) attrs = {}
            var _parseTag = parseTag(tag),
              tagName = _parseTag.tagName,
              id = _parseTag.id,
              classes = _parseTag.classes
            var el = document.createElement(tagName)
            if (id) el.setAttribute('id', id)
            $class.add(el, classes)
            each(children, function (child) {
              if (isStr(child)) {
                el.appendChild(document.createTextNode(child))
              } else if (isEl(child)) {
                el.appendChild(child)
              }
            })
            each(attrs, function (val, key) {
              if (isStr(val)) {
                el.setAttribute(key, val)
              } else if (isFn(val) && startWith(key, 'on')) {
                el.addEventListener(key.slice(2), val, false)
              } else if (key === 'style') {
                $css(el, val)
              }
            })
            return el
          }
          function parseTag(tag) {
            var tagName = 'div'
            var id = ''
            var classes = []
            var words = []
            var word = ''
            for (var i = 0, len = tag.length; i < len; i++) {
              var c = tag[i]
              if (c === '#' || c === '.') {
                words.push(word)
                word = c
              } else {
                word += c
              }
            }
            words.push(word)
            for (var _i = 0, _len2 = words.length; _i < _len2; _i++) {
              word = words[_i]
              if (!word) continue
              if (startWith(word, '#')) {
                id = word.slice(1)
              } else if (startWith(word, '.')) {
                classes.push(word.slice(1))
              } else {
                tagName = word
              }
            }
            return {
              tagName: tagName,
              id: id,
              classes: classes,
            }
          }
  
          return exports
        })({})
  
        /* ------------------------------ root ------------------------------ */
        _licia.root = (function (exports) {
          /* Root object reference, `global` in nodeJs, `window` in browser. */
  
          /* typescript
           * export declare const root: any;
           */
  
          /* dependencies
           * isBrowser
           */
          exports = isBrowser ? window : global
  
          return exports
        })({})
  
        /* ------------------------------ toBool ------------------------------ */
        _licia.toBool = (function (exports) {
          /* Convert value to a boolean.
           *
           * |Name  |Desc             |
           * |------|-----------------|
           * |val   |Value to convert |
           * |return|Converted boolean|
           */
  
          /* example
           * toBool(true); // -> true
           * toBool(null); // -> false
           * toBool(1); // -> true
           * toBool(0); // -> false
           * toBool('0'); // -> false
           * toBool('1'); // -> true
           * toBool('false'); // -> false
           */
  
          /* typescript
           * export declare function toBool(val: any): boolean;
           */
  
          /* dependencies
           * isStr
           */
          exports = function (val) {
            if (isStr(val)) {
              val = val.toLowerCase()
              return val !== '0' && val !== '' && val !== 'false'
            }
            return !!val
          }
  
          return exports
        })({})
  
        return _licia
      })
  
    let domHighlighter
    let highlightConfig
    let isCssLoaded = false
    let $container
    let isHighlighterInited = false
    const showInfo = _licia.cssSupports('clip-path', 'polygon(50% 0px, 0px 100%, 100% 100%)')
    const hasTouchSupport = 'ontouchstart' in _licia.root
  
    function initDomHighlighter() {
      if (isHighlighterInited) {
        return
      }
      let container = _licia.h('div', {
        class: '__chobitsu-hide__',
        style: {
          all: 'initial',
        },
      })
      $container = _licia.$(container)
      document.documentElement.appendChild(container)
  
      let domHighlighterContainer = null
      let shadowRoot = null
      if (container.attachShadow) {
        shadowRoot = container.attachShadow({ mode: 'open' })
      } else if (container.createShadowRoot) {
        shadowRoot = container.createShadowRoot()
      }
      if (shadowRoot) {
        if (typeof GM_getResourceText == 'undefined') {
          GM.getResourceText = GM_getResourceText = async function (aResourceName) {
            let res = await (await fetch(await GM.getResourceUrl(aResourceName))).text()
            let saveRes = await GM.getValue(aResourceName)
            if (typeof saveRes === 'undefined') {
              GM.setValue(aResourceName, res)
            } else {
              return saveRes
            }
            return res
          }
        }
  
        // console.log('111111111', GM.getResourceText);
        // console.log('222222222', GM_getResourceText);
  
        const css = GM_getResourceText('lunaDomHighlighterCSS').replace(
          '/*# sourceMappingURL=luna-dom-highlighter.css.map*/',
          ''
        )
  
        // console.log(css);
  
        const style = document.createElement('style')
        style.textContent = css
        style.type = 'text/css'
        shadowRoot.appendChild(style)
        domHighlighterContainer = document.createElement('div')
        shadowRoot.appendChild(domHighlighterContainer)
      } else {
        domHighlighterContainer = document.createElement('div')
        container.appendChild(domHighlighterContainer)
        if (!isCssLoaded) {
          _licia.evalCss(css)
          isCssLoaded = true
        }
      }
  
      highlightConfig = {
        showRulers: false,
        showExtensionLines: false,
        contrastAlgorithm: 'aa',
        showInfo: showInfo,
        showStyles: true,
        showAccessibilityInfo: false,
        colorFormat: 'hex',
        contentColor: 'rgba(111, 168, 220, .66)',
        paddingColor: 'rgba(147, 196, 125, .55)',
        borderColor: 'rgba(255, 229, 153, .66)',
        marginColor: 'rgba(246, 178, 107, .66)',
        monitorResize: _licia.toBool(_licia.root.ResizeObserver),
      }
      console.log(highlightConfig)
      domHighlighter = new LunaDomHighlighter(domHighlighterContainer, highlightConfig)
  
      window.addEventListener('resize', resizeHandler)
  
      isHighlighterInited = true
    }
  
    const viewportSize = _licia.h('div', {
      class: '__chobitsu-hide__',
      style: {
        position: 'fixed',
        right: 0,
        top: 0,
        background: '#fff',
        fontSize: 13,
        opacity: 0.5,
        padding: '4px 6px',
      },
    })
    let showViewportSizeOnResize = false
  
    function resizeHandler() {
      if (!showViewportSizeOnResize) return
  
      $viewportSize.text(`${window.innerWidth}px × ${window.innerHeight}px`)
      if (viewportSizeTimer) {
        clearTimeout(viewportSizeTimer)
      } else {
        document.documentElement.appendChild(viewportSize)
      }
      viewportSizeTimer = setTimeout(() => {
        $viewportSize.remove()
        viewportSizeTimer = null
      }, 1000)
    }
    const $viewportSize = _licia.$(viewportSize)
    let viewportSizeTimer
  
    function getElementFromPoint(e) {
      if (hasTouchSupport) {
        const touch = e.touches[0] || e.changedTouches[0]
        return document.elementFromPoint(touch.clientX, touch.clientY)
      }
  
      return document.elementFromPoint(e.clientX, e.clientY)
    }
  
    function isValidNode(node) {
      if (node.nodeType === 1) {
        const className = node.getAttribute('class') || ''
        if (
          _licia.contain(className, '__chobitsu-hide__') ||
          _licia.contain(className, 'html2canvas-container')
        ) {
          return false
        }
      }
  
      const isValid = !(node.nodeType === 3 && trim(node.nodeValue || '') === '')
      if (isValid && node.parentNode) {
        return isValidNode(node.parentNode)
      }
  
      return isValid
    }
  
    function moveListener(e) {
      const node = getElementFromPoint(e)
      if (!node || !isValidNode(node)) {
        return
      }
      if (node.nodeType !== 1 && node.nodeType !== 3) return
  
      _licia.defaults(highlightConfig, {
        contentColor: 'transparent',
        paddingColor: 'transparent',
        borderColor: 'transparent',
        marginColor: 'transparent',
      })
      if (!showInfo) {
        _licia.extend(highlightConfig, {
          showInfo: false,
        })
      }
      domHighlighter.highlight(node, highlightConfig)
    }
  
    function outListener() {
      domHighlighter.hide()
    }
  
    function clicklistener(event) {
      console.log(event.target)
  
      window.disableHighlight()
  
      $('#cancelhtml2canvas').text('正在生成截图...')
  
      html2canvas(event.target, { scale: 3, allowTaint: true, useCORS: true }).then((canvas) => {
        canvas.toBlob(function (blob) {
          let url = window.URL.createObjectURL(blob)
          window.open(url)
          setTimeout(() => {
            document.onkeydown = window.keydown_listener
          }, 0);
          $('#tryhtml2canvas').show()
          $('#cancelhtml2canvas').hide()
        })
      })
    }
  
    function addEvent(type, listener) {
      document.documentElement.addEventListener(type, listener, true)
    }
  
    function removeEvent(type, listener) {
      document.documentElement.removeEventListener(type, listener, true)
    }
  
    window.enableHighlight = function () {
      initDomHighlighter()
      addEvent('mousemove', moveListener)
      addEvent('mouseout', outListener)
      addEvent('click', clicklistener)
    }
  
    window.disableHighlight = function () {
      if (isHighlighterInited) {
        domHighlighter.destroy()
        $container.remove()
        window.removeEventListener('resize', resizeHandler)
        removeEvent('mousemove', moveListener)
        removeEvent('mouseout', outListener)
        removeEvent('click', clicklistener)
        isHighlighterInited = false
      }
    }
  
    window.captureHTML = () => {
      console.log('captureHTML...')
  
      // let handle = (event) => {
      //   document.querySelector('html').removeEventListener('click', handle)
      //   console.log(event.target)
  
      //   html2canvas(event.target, { scale: 3, allowTaint: true, useCORS: true }).then((canvas) => {
      //     canvas.toBlob(function (blob) {
      //       let url = window.URL.createObjectURL(blob)
      //       window.open(url)
  
      //       $('#tryhtml2canvas').show()
      //     })
      //   })
      // }
  
      // setTimeout(() => {
      //   document.querySelector('html').addEventListener('click', handle)
      // }, 0)
  
      setTimeout(() => {
        window.keydown_listener = document.onkeydown
        document.onkeydown = (e) => {
          let keyNum = window.event ? e.keyCode : e.which
          console.log('按键:', keyNum)
          if (keyNum === 27) {
            window.disableHighlight()
            setTimeout(() => {
              document.onkeydown = window.keydown_listener
            }, 0);
            $('#tryhtml2canvas').show()
            $('#cancelhtml2canvas').hide()
          }
        }
        window.enableHighlight()
      }, 0)
  
      $('#cancelhtml2canvas').text('按 ESC 取消截图')
      $('#cancelhtml2canvas').show()
      $('#tryhtml2canvas').hide()
    }
  
    let capturediv = document.createElement('div')
    capturediv.innerHTML = `
    <div id="tryhtml2canvas"
      style="background-image: linear-gradient(0deg, #558b2f, #7cb342);cursor: pointer; opacity: 0.7; position: fixed;display: flex;bottom: 40px;right: 40px;z-index: 100001;width: 50px;height: 50px;border-radius: 50%;box-shadow: 0 2px 2px 0 rgba(0,0,0,0.14), 0 1px 5px 0 rgba(0,0,0,0.12), 0 3px 1px -2px rgba(0,0,0,0.2);-webkit-box-pack: center;-webkit-justify-content: center;-webkit-box-align: center;-webkit-align-items: center;">
      <div style="overflow: hidden;">
        <img
          src="data:image/svg+xml;base64,PHN2ZyBmaWxsPSIjZmZmZmZmIiBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjMuMiIvPgogICAgPHBhdGggZD0iTTkgMkw3LjE3IDRINGMtMS4xIDAtMiAuOS0yIDJ2MTJjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY2YzAtMS4xLS45LTItMi0yaC0zLjE3TDE1IDJIOXptMyAxNWMtMi43NiAwLTUtMi4yNC01LTVzMi4yNC01IDUtNSA1IDIuMjQgNSA1LTIuMjQgNS01IDV6Ii8+CiAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIi8+Cjwvc3ZnPgo="
          alt="Try html2canvas" style="transform: translateX(-210px); filter: drop-shadow(210px 0 0 black);">
      </div>
    </div>
    `
    document.body.appendChild(capturediv)
  
    let canceldiv = document.createElement('div')
    canceldiv.innerHTML = `
    <div id="cancelhtml2canvas"
      style="background-color: rgba(170, 170, 170, 0.8); cursor: pointer; position: fixed; display: none; bottom: 40px; right: 40px; z-index: 100001; padding: 10px; font-size: 20px; color: darkred; box-shadow: rgba(0, 0, 0, 0.14) 0px 2px 2px 0px, rgba(0, 0, 0, 0.12) 0px 1px 5px 0px, rgba(0, 0, 0, 0.2) 0px 3px 1px -2px; -webkit-box-pack: center; justify-content: center; -webkit-box-align: center; align-items: center;">
      <div style="overflow: hidden;">按 ESC 取消截图</div>
    </div>
    `
    document.body.appendChild(canceldiv)
  
    let tryhtml2canvasE = capturediv.querySelector('#tryhtml2canvas')
    tryhtml2canvasE.onmouseenter = () => {
      tryhtml2canvasE.style.opacity = 1
    }
    tryhtml2canvasE.onmouseleave = () => {
      tryhtml2canvasE.style.opacity = 0.7
    }
  
    let isDragging = false
    let startX, startY, offsetX, offsetY
  
    const onMouseMove = (event) => {
      if (!isDragging) return
      console.log("onMouseMove")
      const currentX = event.clientX
      const currentY = event.clientY
      const dx = currentX - startX
      const dy = currentY - startY
  
      if (Math.abs(dx) > 5 || Math.abs(dy) > 5) {
        tryhtml2canvasE.style.left = `${currentX - offsetX}px`
        tryhtml2canvasE.style.top = `${currentY - offsetY}px`
        tryhtml2canvasE.removeEventListener('click', window.captureHTML)
      }
    }
  
    const onMouseDown = (event) => {
      console.log("onMouseDown")
      isDragging = true
      startX = event.clientX
      startY = event.clientY
      offsetX = startX - tryhtml2canvasE.getBoundingClientRect().left
      offsetY = startY - tryhtml2canvasE.getBoundingClientRect().top
      tryhtml2canvasE.style.cursor = 'grabbing'
      document.addEventListener('mousemove', onMouseMove)
      document.addEventListener('mouseup', onMouseUp)
    }
  
    const onMouseUp = (event) => {
      if (isDragging) {
        console.log("onMouseUp")
        isDragging = false
        tryhtml2canvasE.style.cursor = 'pointer'
        setTimeout(() => {
          tryhtml2canvasE.addEventListener('click', window.captureHTML)
        }, 0);
        document.removeEventListener('mousemove', onMouseMove)
        document.removeEventListener('mouseup', onMouseUp)
      }
    }
  
    tryhtml2canvasE.addEventListener('mousedown', onMouseDown)
    tryhtml2canvasE.addEventListener('click', window.captureHTML)
  })()