wangeditor/dist/wangEditor.js

wangEditor - 轻量级 web 富文本编辑器，配置方便，使用简单，开源免费

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["wangEditor"] = factory();
	else
		root["wangEditor"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 141);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}

module.exports = _interopRequireDefault;

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(142);

/***/ }),
/* 2 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__createBinding", function() { return __createBinding; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spreadArrays", function() { return __spreadArrays; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spreadArray", function() { return __spreadArray; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldGet", function() { return __classPrivateFieldGet; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldSet", function() { return __classPrivateFieldSet; });
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics = function(d, b) {
    extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
    return extendStatics(d, b);
};

function __extends(d, b) {
    if (typeof b !== "function" && b !== null)
        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
    extendStatics(d, b);
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    }
    return __assign.apply(this, arguments);
}

function __rest(s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
}

function __decorate(decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
}

function __param(paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
}

function __metadata(metadataKey, metadataValue) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function __generator(thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
}

var __createBinding = Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
});

function __exportStar(m, o) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}

function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}

function __read(o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
}

/** @deprecated */
function __spread() {
    for (var ar = [], i = 0; i < arguments.length; i++)
        ar = ar.concat(__read(arguments[i]));
    return ar;
}

/** @deprecated */
function __spreadArrays() {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
}

function __spreadArray(to, from) {
    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
        to[j] = from[i];
    return to;
}

function __await(v) {
    return this instanceof __await ? (this.v = v, this) : new __await(v);
}

function __asyncGenerator(thisArg, _arguments, generator) {
    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
    var g = generator.apply(thisArg, _arguments || []), i, q = [];
    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
    function fulfill(value) { resume("next", value); }
    function reject(value) { resume("throw", value); }
    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}

function __asyncDelegator(o) {
    var i, p;
    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}

function __asyncValues(o) {
    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
    var m = o[Symbol.asyncIterator], i;
    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}

function __makeTemplateObject(cooked, raw) {
    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
    return cooked;
};

var __setModuleDefault = Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
};

function __importStar(mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
}

function __importDefault(mod) {
    return (mod && mod.__esModule) ? mod : { default: mod };
}

function __classPrivateFieldGet(receiver, privateMap) {
    if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to get private field on non-instance");
    }
    return privateMap.get(receiver);
}

function __classPrivateFieldSet(receiver, privateMap, value) {
    if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to set private field on non-instance");
    }
    privateMap.set(receiver, value);
    return value;
}


/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * @description 封装 DOM 操作
 * @wangfupeng
 */

var _interopRequireDefault = __webpack_require__(0);

var _defineProperty = _interopRequireDefault(__webpack_require__(1));

var _isArray = _interopRequireDefault(__webpack_require__(89));

var _forEach = _interopRequireDefault(__webpack_require__(4));

var _map = _interopRequireDefault(__webpack_require__(26));

var _trim = _interopRequireDefault(__webpack_require__(17));

var _map2 = _interopRequireDefault(__webpack_require__(121));

var _indexOf = _interopRequireDefault(__webpack_require__(27));

var _splice = _interopRequireDefault(__webpack_require__(91));

var _filter = _interopRequireDefault(__webpack_require__(70));

var _includes = _interopRequireDefault(__webpack_require__(28));

var _bind = _interopRequireDefault(__webpack_require__(57));

(0, _defineProperty["default"])(exports, "__esModule", {
  value: true
});
exports.DomElement = void 0;

var tslib_1 = __webpack_require__(2);

var util_1 = __webpack_require__(6);

var AGENT_EVENTS = [];
/**
 * 根据 html 字符串创建 elem
 * @param {String} html html
 */

function _createElemByHTML(html) {
  var div = document.createElement('div');
  div.innerHTML = html;
  var elems = div.children;
  return util_1.toArray(elems);
}
/**
 * 判断是否是 DOM List
 * @param selector DOM 元素或列表
 */


function _isDOMList(selector) {
  if (!selector) {
    return false;
  }

  if (selector instanceof HTMLCollection || selector instanceof NodeList) {
    return true;
  }

  return false;
}
/**
 * 封装 querySelectorAll
 * @param selector css 选择器
 */


function _querySelectorAll(selector) {
  var elems = document.querySelectorAll(selector);
  return util_1.toArray(elems);
}
/**
 * 封装 _styleArrTrim
 * @param styleArr css
 */


function _styleArrTrim(style) {
  var styleArr = [];
  var resultArr = [];

  if (!(0, _isArray["default"])(style)) {
    // 有 style，将 style 按照 `;` 拆分为数组
    styleArr = style.split(';');
  } else {
    styleArr = style;
  }

  (0, _forEach["default"])(styleArr).call(styleArr, function (item) {
    var _context;

    // 对每项样式，按照 : 拆分为 key 和 value
    var arr = (0, _map["default"])(_context = item.split(':')).call(_context, function (i) {
      return (0, _trim["default"])(i).call(i);
    });

    if (arr.length === 2) {
      resultArr.push(arr[0] + ':' + arr[1]);
    }
  });
  return resultArr;
} // 构造函数


var DomElement =
/** @class */
function () {
  /**
   * 构造函数
   * @param selector 任一类型的选择器
   */
  function DomElement(selector) {
    // 初始化属性
    this.elems = [];
    this.length = this.elems.length;
    this.dataSource = new _map2["default"]();

    if (!selector) {
      return;
    } // 原本就是 DomElement 实例，则直接返回


    if (selector instanceof DomElement) {
      return selector;
    }

    var selectorResult = []; // 存储查询结果

    var nodeType = selector instanceof Node ? selector.nodeType : -1;
    this.selector = selector;

    if (nodeType === 1 || nodeType === 9) {
      selectorResult = [selector];
    } else if (_isDOMList(selector)) {
      // DOM List
      selectorResult = util_1.toArray(selector);
    } else if (selector instanceof Array) {
      // Element 数组（其他数据类型，暂时忽略）
      selectorResult = selector;
    } else if (typeof selector === 'string') {
      var _context2;

      // 字符串
      var tmpSelector = (0, _trim["default"])(_context2 = selector.replace('/\n/mg', '')).call(_context2);

      if ((0, _indexOf["default"])(tmpSelector).call(tmpSelector, '<') === 0) {
        // 如 <div>
        selectorResult = _createElemByHTML(tmpSelector);
      } else {
        // 如 #id .class
        selectorResult = _querySelectorAll(tmpSelector);
      }
    }

    var length = selectorResult.length;

    if (!length) {
      // 空数组
      return this;
    } // 加入 DOM 节点


    var i = 0;

    for (; i < length; i++) {
      this.elems.push(selectorResult[i]);
    }

    this.length = length;
  }

  (0, _defineProperty["default"])(DomElement.prototype, "id", {
    /**
     * 获取元素 id
     */
    get: function get() {
      return this.elems[0].id;
    },
    enumerable: false,
    configurable: true
  });
  /**
   * 遍历所有元素，执行回调函数
   * @param fn 回调函数
   */

  DomElement.prototype.forEach = function (fn) {
    for (var i = 0; i < this.length; i++) {
      var elem = this.elems[i];
      var result = fn.call(elem, elem, i);

      if (result === false) {
        break;
      }
    }

    return this;
  };
  /**
   * 克隆元素
   * @param deep 是否深度克隆
   */


  DomElement.prototype.clone = function (deep) {
    var _context3;

    if (deep === void 0) {
      deep = false;
    }

    var cloneList = [];
    (0, _forEach["default"])(_context3 = this.elems).call(_context3, function (elem) {
      cloneList.push(elem.cloneNode(!!deep));
    });
    return $(cloneList);
  };
  /**
   * 获取第几个元素
   * @param index index
   */


  DomElement.prototype.get = function (index) {
    if (index === void 0) {
      index = 0;
    }

    var length = this.length;

    if (index >= length) {
      index = index % length;
    }

    return $(this.elems[index]);
  };
  /**
   * 获取第一个元素
   */


  DomElement.prototype.first = function () {
    return this.get(0);
  };
  /**
   * 获取最后一个元素
   */


  DomElement.prototype.last = function () {
    var length = this.length;
    return this.get(length - 1);
  };

  DomElement.prototype.on = function (type, selector, fn) {
    var _context4;

    if (!type) return this; // 没有 selector ，只有 type 和 fn

    if (typeof selector === 'function') {
      fn = selector;
      selector = '';
    }

    return (0, _forEach["default"])(_context4 = this).call(_context4, function (elem) {
      // 没有事件代理
      if (!selector) {
        // 无代理
        elem.addEventListener(type, fn);
        return;
      } // 有事件代理


      var agentFn = function agentFn(e) {
        var target = e.target;

        if (target.matches(selector)) {
          ;
          fn.call(target, e);
        }
      };

      elem.addEventListener(type, agentFn); // 缓存代理事件

      AGENT_EVENTS.push({
        elem: elem,
        selector: selector,
        fn: fn,
        agentFn: agentFn
      });
    });
  };

  DomElement.prototype.off = function (type, selector, fn) {
    var _context5;

    if (!type) return this; // 没有 selector ，只有 type 和 fn

    if (typeof selector === 'function') {
      fn = selector;
      selector = '';
    }

    return (0, _forEach["default"])(_context5 = this).call(_context5, function (elem) {
      // 解绑事件代理
      if (selector) {
        var idx = -1;

        for (var i = 0; i < AGENT_EVENTS.length; i++) {
          var item = AGENT_EVENTS[i];

          if (item.selector === selector && item.fn === fn && item.elem === elem) {
            idx = i;
            break;
          }
        }

        if (idx !== -1) {
          var agentFn = (0, _splice["default"])(AGENT_EVENTS).call(AGENT_EVENTS, idx, 1)[0].agentFn;
          elem.removeEventListener(type, agentFn);
        }
      } else {
        // @ts-ignore
        elem.removeEventListener(type, fn);
      }
    });
  };

  DomElement.prototype.attr = function (key, val) {
    var _context6;

    if (val == null) {
      // 获取数据
      return this.elems[0].getAttribute(key) || '';
    } // 否则，设置属性


    return (0, _forEach["default"])(_context6 = this).call(_context6, function (elem) {
      elem.setAttribute(key, val);
    });
  };
  /**
   * 删除 属性
   * @param key key
   */


  DomElement.prototype.removeAttr = function (key) {
    var _context7;

    (0, _forEach["default"])(_context7 = this).call(_context7, function (elem) {
      elem.removeAttribute(key);
    });
  };
  /**
   * 添加 css class
   * @param className css class
   */


  DomElement.prototype.addClass = function (className) {
    var _context8;

    if (!className) {
      return this;
    }

    return (0, _forEach["default"])(_context8 = this).call(_context8, function (elem) {
      if (elem.className) {
        // 当前有 class
        var arr = elem.className.split(/\s/);
        arr = (0, _filter["default"])(arr).call(arr, function (item) {
          return !!(0, _trim["default"])(item).call(item);
        }); // 添加 class

        if ((0, _indexOf["default"])(arr).call(arr, className) < 0) {
          arr.push(className);
        } // 修改 elem.class


        elem.className = arr.join(' ');
      } else {
        // 当前没有 class
        elem.className = className;
      }
    });
  };
  /**
   * 添加 css class
   * @param className css class
   */


  DomElement.prototype.removeClass = function (className) {
    var _context9;

    if (!className) {
      return this;
    }

    return (0, _forEach["default"])(_context9 = this).call(_context9, function (elem) {
      if (!elem.className) {
        // 当前无 class
        return;
      }

      var arr = elem.className.split(/\s/);
      arr = (0, _filter["default"])(arr).call(arr, function (item) {
        item = (0, _trim["default"])(item).call(item); // 删除 class

        if (!item || item === className) {
          return false;
        }

        return true;
      }); // 修改 elem.class

      elem.className = arr.join(' ');
    });
  };
  /**
   * 是否有传入的 css class
   * @param className css class
   */


  DomElement.prototype.hasClass = function (className) {
    if (!className) {
      return false;
    }

    var elem = this.elems[0];

    if (!elem.className) {
      // 当前无 class
      return false;
    }

    var arr = elem.className.split(/\s/);
    return (0, _includes["default"])(arr).call(arr, className); // 是否包含
  };
  /**
   * 修改 css
   * @param key css key
   * @param val css value
   */
  // css(key: string): string


  DomElement.prototype.css = function (key, val) {
    var _context10;

    var currentStyle;

    if (val == '') {
      currentStyle = '';
    } else {
      currentStyle = key + ":" + val + ";";
    }

    return (0, _forEach["default"])(_context10 = this).call(_context10, function (elem) {
      var _context11;

      var style = (0, _trim["default"])(_context11 = elem.getAttribute('style') || '').call(_context11);

      if (style) {
        // 有 style，将 style 按照 `;` 拆分为数组
        var resultArr = _styleArrTrim(style); // 替换现有的 style


        resultArr = (0, _map["default"])(resultArr).call(resultArr, function (item) {
          if ((0, _indexOf["default"])(item).call(item, key) === 0) {
            return currentStyle;
          } else {
            return item;
          }
        }); // 新增 style

        if (currentStyle != '' && (0, _indexOf["default"])(resultArr).call(resultArr, currentStyle) < 0) {
          resultArr.push(currentStyle);
        } // 去掉 空白


        if (currentStyle == '') {
          resultArr = _styleArrTrim(resultArr);
        } // 重新设置 style


        elem.setAttribute('style', resultArr.join('; '));
      } else {
        // 当前没有 style
        elem.setAttribute('style', currentStyle);
      }
    });
  };
  /**
   * 封装 getBoundingClientRect
   */


  DomElement.prototype.getBoundingClientRect = function () {
    var elem = this.elems[0];
    return elem.getBoundingClientRect();
  };
  /**
   * 显示
   */


  DomElement.prototype.show = function () {
    return this.css('display', 'block');
  };
  /**
   * 隐藏
   */


  DomElement.prototype.hide = function () {
    return this.css('display', 'none');
  };
  /**
   * 获取子节点（只有 DOM 元素）
   */


  DomElement.prototype.children = function () {
    var elem = this.elems[0];

    if (!elem) {
      return null;
    }

    return $(elem.children);
  };
  /**
   * 获取子节点（包括文本节点）
   */


  DomElement.prototype.childNodes = function () {
    var elem = this.elems[0];

    if (!elem) {
      return null;
    }

    return $(elem.childNodes);
  };
  /**
   * 将子元素全部替换
   * @param $children 新的child节点
   */


  DomElement.prototype.replaceChildAll = function ($children) {
    var parent = this.getNode();
    var elem = this.elems[0];

    while (elem.hasChildNodes()) {
      parent.firstChild && elem.removeChild(parent.firstChild);
    }

    this.append($children);
  };
  /**
   * 增加子节点
   * @param $children 子节点
   */


  DomElement.prototype.append = function ($children) {
    var _context12;

    return (0, _forEach["default"])(_context12 = this).call(_context12, function (elem) {
      (0, _forEach["default"])($children).call($children, function (child) {
        elem.appendChild(child);
      });
    });
  };
  /**
   * 移除当前节点
   */


  DomElement.prototype.remove = function () {
    var _context13;

    return (0, _forEach["default"])(_context13 = this).call(_context13, function (elem) {
      if (elem.remove) {
        elem.remove();
      } else {
        var parent_1 = elem.parentElement;
        parent_1 && parent_1.removeChild(elem);
      }
    });
  };
  /**
   * 当前元素，是否包含某个子元素
   * @param $child 子元素
   */


  DomElement.prototype.isContain = function ($child) {
    var elem = this.elems[0];
    var child = $child.elems[0];
    return elem.contains(child);
  };
  /**
   * 获取当前元素 nodeName
   */


  DomElement.prototype.getNodeName = function () {
    var elem = this.elems[0];
    return elem.nodeName;
  };
  /**
   * 根据元素位置获取元素节点（默认获取0位置的节点）
   * @param n 元素节点位置
   */


  DomElement.prototype.getNode = function (n) {
    if (n === void 0) {
      n = 0;
    }

    var elem;
    elem = this.elems[n];
    return elem;
  };
  /**
   * 查询
   * @param selector css 选择器
   */


  DomElement.prototype.find = function (selector) {
    var elem = this.elems[0];
    return $(elem.querySelectorAll(selector));
  };

  DomElement.prototype.text = function (val) {
    if (!val) {
      // 获取 text
      var elem = this.elems[0];
      return elem.innerHTML.replace(/<[^>]+>/g, function () {
        return '';
      });
    } else {
      var _context14;

      // 设置 text
      return (0, _forEach["default"])(_context14 = this).call(_context14, function (elem) {
        elem.innerHTML = val;
      });
    }
  };

  DomElement.prototype.html = function (val) {
    var elem = this.elems[0];

    if (!val) {
      // 获取 html
      return elem.innerHTML;
    } else {
      // 设置 html
      elem.innerHTML = val;
      return this;
    }
  };
  /**
   * 获取元素 value
   */


  DomElement.prototype.val = function () {
    var _context15;

    var elem = this.elems[0];
    return (0, _trim["default"])(_context15 = elem.value).call(_context15); // 暂用 any
  };
  /**
   * focus 到当前元素
   */


  DomElement.prototype.focus = function () {
    var _context16;

    return (0, _forEach["default"])(_context16 = this).call(_context16, function (elem) {
      elem.focus();
    });
  };
  /**
   * 当前元素前一个兄弟节点
   */


  DomElement.prototype.prev = function () {
    var elem = this.elems[0];
    return $(elem.previousElementSibling);
  };
  /**
   * 当前元素后一个兄弟节点
   * 不包括文本节点、注释节点）
   */


  DomElement.prototype.next = function () {
    var elem = this.elems[0];
    return $(elem.nextElementSibling);
  };
  /**
   * 获取当前节点的下一个兄弟节点
   * 包括文本节点、注释节点即回车、换行、空格、文本等等）
   */


  DomElement.prototype.getNextSibling = function () {
    var elem = this.elems[0];
    return $(elem.nextSibling);
  };
  /**
   * 获取父元素
   */


  DomElement.prototype.parent = function () {
    var elem = this.elems[0];
    return $(elem.parentElement);
  };
  /**
   * 查找父元素，直到满足 selector 条件
   * @param selector css 选择器
   * @param curElem 从哪个元素开始查找，默认为当前元素
   */


  DomElement.prototype.parentUntil = function (selector, curElem) {
    var elem = curElem || this.elems[0];

    if (elem.nodeName === 'BODY') {
      return null;
    }

    var parent = elem.parentElement;

    if (parent === null) {
      return null;
    }

    if (parent.matches(selector)) {
      // 找到，并返回
      return $(parent);
    } // 继续查找，递归


    return this.parentUntil(selector, parent);
  };
  /**
   * 查找父元素，直到满足 selector 条件,或者 到达 编辑区域容器以及菜单栏容器
   * @param selector css 选择器
   * @param curElem 从哪个元素开始查找，默认为当前元素
   */


  DomElement.prototype.parentUntilEditor = function (selector, editor, curElem) {
    var elem = curElem || this.elems[0];

    if ($(elem).equal(editor.$textContainerElem) || $(elem).equal(editor.$toolbarElem)) {
      return null;
    }

    var parent = elem.parentElement;

    if (parent === null) {
      return null;
    }

    if (parent.matches(selector)) {
      // 找到，并返回
      return $(parent);
    } // 继续查找，递归


    return this.parentUntilEditor(selector, editor, parent);
  };
  /**
   * 判读是否相等
   * @param $elem 元素
   */


  DomElement.prototype.equal = function ($elem) {
    if ($elem instanceof DomElement) {
      return this.elems[0] === $elem.elems[0];
    } else if ($elem instanceof HTMLElement) {
      return this.elems[0] === $elem;
    } else {
      return false;
    }
  };
  /**
   * 将该元素插入到某个元素前面
   * @param selector css 选择器
   */


  DomElement.prototype.insertBefore = function (selector) {
    var _context17;

    var $referenceNode = $(selector);
    var referenceNode = $referenceNode.elems[0];

    if (!referenceNode) {
      return this;
    }

    return (0, _forEach["default"])(_context17 = this).call(_context17, function (elem) {
      var parent = referenceNode.parentNode;
      parent === null || parent === void 0 ? void 0 : parent.insertBefore(elem, referenceNode);
    });
  };
  /**
   * 将该元素插入到selector元素后面
   * @param selector css 选择器
   */


  DomElement.prototype.insertAfter = function (selector) {
    var _context18;

    var $referenceNode = $(selector);
    var referenceNode = $referenceNode.elems[0];
    var anchorNode = referenceNode && referenceNode.nextSibling;

    if (!referenceNode) {
      return this;
    }

    return (0, _forEach["default"])(_context18 = this).call(_context18, function (elem) {
      var parent = referenceNode.parentNode;

      if (anchorNode) {
        parent.insertBefore(elem, anchorNode);
      } else {
        parent.appendChild(elem);
      }
    });
  };
  /**
   * 设置/获取 数据
   * @param key key
   * @param value value
   */


  DomElement.prototype.data = function (key, value) {
    if (value != null) {
      // 设置数据
      this.dataSource.set(key, value);
    } else {
      // 获取数据
      return this.dataSource.get(key);
    }
  };
  /**
   * 获取当前节点的顶级(段落)
   * @param editor 富文本实例
   */


  DomElement.prototype.getNodeTop = function (editor) {
    // 异常抛出，空的 DomElement 直接返回
    if (this.length < 1) {
      return this;
    } // 获取父级元素，并判断是否是 编辑区域
    // 如果是则返回当前节点


    var $parent = this.parent(); // fix：添加当前元素与编辑区元素的比较，防止传入的当前元素就是编辑区元素而造成的获取顶级元素为空的情况

    if (editor.$textElem.equal(this) || editor.$textElem.equal($parent)) {
      return this;
    } // 到了此处，即代表当前节点不是顶级段落
    // 将当前节点存放于父节点的 prior 字段下
    // 主要用于 回溯 子节点
    // 例如：ul ol 等标签
    // 实际操作的节点是 li 但是一个 ul ol 的子节点可能有多个
    // 所以需要对其进行 回溯 找到对应的子节点


    $parent.prior = this;
    return $parent.getNodeTop(editor);
  };
  /**
   * 获取当前 节点 基与上一个拥有相对或者解决定位的父容器的位置
   * @param editor 富文本实例
   */


  DomElement.prototype.getOffsetData = function () {
    var $node = this.elems[0];
    return {
      top: $node.offsetTop,
      left: $node.offsetLeft,
      width: $node.offsetWidth,
      height: $node.offsetHeight,
      parent: $node.offsetParent
    };
  };
  /**
   * 从上至下进行滚动
   * @param top 滚动的值
   */


  DomElement.prototype.scrollTop = function (top) {
    var $node = this.elems[0];
    $node.scrollTo({
      top: top
    });
  };

  return DomElement;
}();

exports.DomElement = DomElement; // new 一个对象

function $() {
  var arg = [];

  for (var _i = 0; _i < arguments.length; _i++) {
    arg[_i] = arguments[_i];
  }

  return new ((0, _bind["default"])(DomElement).apply(DomElement, tslib_1.__spreadArrays([void 0], arg)))();
}

exports["default"] = $;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(180);

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(8);
var getOwnPropertyDescriptor = __webpack_require__(71).f;
var isForced = __webpack_require__(101);
var path = __webpack_require__(9);
var bind = __webpack_require__(40);
var createNonEnumerableProperty = __webpack_require__(19);
var has = __webpack_require__(16);

var wrapConstructor = function (NativeConstructor) {
  var Wrapper = function (a, b, c) {
    if (this instanceof NativeConstructor) {
      switch (arguments.length) {
        case 0: return new NativeConstructor();
        case 1: return new NativeConstructor(a);
        case 2: return new NativeConstructor(a, b);
      } return new NativeConstructor(a, b, c);
    } return NativeConstructor.apply(this, arguments);
  };
  Wrapper.prototype = NativeConstructor.prototype;
  return Wrapper;
};

/*
  options.target      - name of the target object
  options.global      - target is the global object
  options.stat        - export as static methods of target
  options.proto       - export as prototype methods of target
  options.real        - real prototype method for the `pure` version
  options.forced      - export even if the native feature is available
  options.bind        - bind methods to the target, required for the `pure` version
  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
  options.sham        - add a flag to not completely full polyfills
  options.enumerable  - export as enumerable property
  options.noTargetGet - prevent calling a getter on target
*/
module.exports = function (options, source) {
  var TARGET = options.target;
  var GLOBAL = options.global;
  var STATIC = options.stat;
  var PROTO = options.proto;

  var nativeSource = GLOBAL ? global : STATIC ? global[TARGET] : (global[TARGET] || {}).prototype;

  var target = GLOBAL ? path : path[TARGET] || (path[TARGET] = {});
  var targetPrototype = target.prototype;

  var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE;
  var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor;

  for (key in source) {
    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
    // contains in native
    USE_NATIVE = !FORCED && nativeSource && has(nativeSource, key);

    targetProperty = target[key];

    if (USE_NATIVE) if (options.noTargetGet) {
      descriptor = getOwnPropertyDescriptor(nativeSource, key);
      nativeProperty = descriptor && descriptor.value;
    } else nativeProperty = nativeSource[key];

    // export native or implementation
    sourceProperty = (USE_NATIVE && nativeProperty) ? nativeProperty : source[key];

    if (USE_NATIVE && typeof targetProperty === typeof sourceProperty) continue;

    // bind timers to global for call from export context
    if (options.bind && USE_NATIVE) resultProperty = bind(sourceProperty, global);
    // wrap global constructors for prevent changs in this version
    else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty);
    // make static versions for prototype methods
    else if (PROTO && typeof sourceProperty == 'function') resultProperty = bind(Function.call, sourceProperty);
    // default case
    else resultProperty = sourceProperty;

    // add a flag to not completely full polyfills
    if (options.sham || (sourceProperty && sourceProperty.sham) || (targetProperty && targetProperty.sham)) {
      createNonEnumerableProperty(resultProperty, 'sham', true);
    }

    target[key] = resultProperty;

    if (PROTO) {
      VIRTUAL_PROTOTYPE = TARGET + 'Prototype';
      if (!has(path, VIRTUAL_PROTOTYPE)) {
        createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {});
      }
      // export virtual prototype methods
      path[VIRTUAL_PROTOTYPE][key] = sourceProperty;
      // export real prototype methods
      if (options.real && targetPrototype && !targetPrototype[key]) {
        createNonEnumerableProperty(targetPrototype, key, sourceProperty);
      }
    }
  }
};


/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * @description 工具函数集合
 * @author wangfupeng
 */

var _interopRequireDefault = __webpack_require__(0);

var _typeof2 = _interopRequireDefault(__webpack_require__(92));

var _defineProperty = _interopRequireDefault(__webpack_require__(1));

var _parseInt2 = _interopRequireDefault(__webpack_require__(256));

var _slice = _interopRequireDefault(__webpack_require__(45));

var _setTimeout2 = _interopRequireDefault(__webpack_require__(46));

var _isArray = _interopRequireDefault(__webpack_require__(89));

var _map = _interopRequireDefault(__webpack_require__(26));

(0, _defineProperty["default"])(exports, "__esModule", {
  value: true
});
exports.hexToRgb = exports.getRandomCode = exports.toArray = exports.deepClone = exports.isFunction = exports.debounce = exports.throttle = exports.arrForEach = exports.forEach = exports.replaceSpecialSymbol = exports.replaceHtmlSymbol = exports.getRandom = exports.UA = void 0;

var tslib_1 = __webpack_require__(2);

var NavUA =
/** @class */
function () {
  function NavUA() {
    this._ua = navigator.userAgent;

    var math = this._ua.match(/(Edge?)\/(\d+)/);

    this.isOldEdge = math && math[1] == 'Edge' && (0, _parseInt2["default"])(math[2]) < 19 ? true : false;
    this.isFirefox = /Firefox\/\d+/.test(this._ua) && !/Seamonkey\/\d+/.test(this._ua) ? true : false;
  } // 是否为 IE


  NavUA.prototype.isIE = function () {
    return 'ActiveXObject' in window;
  }; // 是否为 webkit


  NavUA.prototype.isWebkit = function () {
    return /webkit/i.test(this._ua);
  };

  return NavUA;
}(); // 和 UA 相关的属性


exports.UA = new NavUA();
/**
 * 获取随机字符
 * @param prefix 前缀
 */

function getRandom(prefix) {
  var _context;

  if (prefix === void 0) {
    prefix = '';
  }

  return prefix + (0, _slice["default"])(_context = Math.random().toString()).call(_context, 2);
}

exports.getRandom = getRandom;
/**
 * 替换 html 特殊字符
 * @param html html 字符串
 */

function replaceHtmlSymbol(html) {
  return html.replace(/</gm, '&lt;').replace(/>/gm, '&gt;').replace(/"/gm, '&quot;').replace(/(\r\n|\r|\n)/g, '<br/>');
}

exports.replaceHtmlSymbol = replaceHtmlSymbol;

function replaceSpecialSymbol(value) {
  return value.replace(/&lt;/gm, '<').replace(/&gt;/gm, '>').replace(/&quot;/gm, '"');
}

exports.replaceSpecialSymbol = replaceSpecialSymbol;

function forEach(obj, fn) {
  for (var key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      var result = fn(key, obj[key]);

      if (result === false) {
        // 提前终止循环
        break;
      }
    }
  }
}

exports.forEach = forEach;
/**
 * 遍历类数组
 * @param fakeArr 类数组
 * @param fn 回调函数
 */

function arrForEach(fakeArr, fn) {
  var i, item, result;
  var length = fakeArr.length || 0;

  for (i = 0; i < length; i++) {
    item = fakeArr[i];
    result = fn.call(fakeArr, item, i);

    if (result === false) {
      break;
    }
  }
}

exports.arrForEach = arrForEach;
/**
 * 节流
 * @param fn 函数
 * @param interval 间隔时间，毫秒
 */

function throttle(fn, interval) {
  if (interval === void 0) {
    interval = 200;
  }

  var flag = false;
  return function () {
    var _this = this;

    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    if (!flag) {
      flag = true;
      (0, _setTimeout2["default"])(function () {
        flag = false;
        fn.call.apply(fn, tslib_1.__spreadArrays([_this], args)); // this 报语法错误，先用 null
      }, interval);
    }
  };
}

exports.throttle = throttle;
/**
 * 防抖
 * @param fn 函数
 * @param delay 间隔时间，毫秒
 */

function debounce(fn, delay) {
  if (delay === void 0) {
    delay = 200;
  }

  var lastFn = 0;
  return function () {
    var _this = this;

    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    if (lastFn) {
      window.clearTimeout(lastFn);
    }

    lastFn = (0, _setTimeout2["default"])(function () {
      lastFn = 0;
      fn.call.apply(fn, tslib_1.__spreadArrays([_this], args)); // this 报语法错误，先用 null
    }, delay);
  };
}

exports.debounce = debounce;
/**
 * isFunction 是否是函数
 * @param fn 函数
 */

function isFunction(fn) {
  return typeof fn === 'function';
}

exports.isFunction = isFunction;
/**
 * 引用与非引用值 深拷贝方法
 * @param data
 */

function deepClone(data) {
  if ((0, _typeof2["default"])(data) !== 'object' || typeof data == 'function' || data === null) {
    return data;
  }

  var item;

  if ((0, _isArray["default"])(data)) {
    item = [];
  }

  if (!(0, _isArray["default"])(data)) {
    item = {};
  }

  for (var i in data) {
    if (Object.prototype.hasOwnProperty.call(data, i)) {
      item[i] = deepClone(data[i]);
    }
  }

  return item;
}

exports.deepClone = deepClone;
/**
 * 将可遍历的对象转换为数组
 * @param data 可遍历的对象
 */

function toArray(data) {
  return (0, _slice["default"])(Array.prototype).call(data);
}

exports.toArray = toArray;
/**
 * 唯一id生成
 * @param length 随机数长度
 */

function getRandomCode() {
  var _context2;

  return (0, _slice["default"])(_context2 = Math.random().toString(36)).call(_context2, -5);
}

exports.getRandomCode = getRandomCode;
/**
 * hex color 转换成 rgb
 * @param hex string
 */

function hexToRgb(hex) {
  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
  if (result == null) return null;
  var colors = (0, _map["default"])(result).call(result, function (i) {
    return (0, _parseInt2["default"])(i, 16);
  });
  var r = colors[1];
  var g = colors[2];
  var b = colors[3];
  return "rgb(" + r + ", " + g + ", " + b + ")";
}

exports.hexToRgb = hexToRgb;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * @description 常量
 * @author wangfupeng
 */

var _interopRequireDefault = __webpack_require__(0);

var _defineProperty = _interopRequireDefault(__webpack_require__(1));

(0, _defineProperty["default"])(exports, "__esModule", {
  value: true
});
exports.EMPTY_P_REGEX = exports.EMPTY_P_LAST_REGEX = exports.EMPTY_P = exports.urlRegex = exports.EMPTY_FN = void 0;

function EMPTY_FN() {}

exports.EMPTY_FN = EMPTY_FN; //用于校验是否为url格式字符串

exports.urlRegex = /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-.,@?^=%&amp;:/~+#]*[\w\-@?^=%&amp;/~+#])?/g; // 编辑器为了方便继续输入/换行等原因 主动生成的空标签

exports.EMPTY_P = '<p data-we-empty-p=""><br></p>'; // 用于校验dom中最后 由编辑器主动生成的空标签结构

exports.EMPTY_P_LAST_REGEX = /<p data-we-empty-p=""><br\/?><\/p>$/gim; // 用于校验dom中所有 由编辑器主动生成的空标签结构

exports.EMPTY_P_REGEX = /<p data-we-empty-p="">/gim;

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {var check = function (it) {
  return it && it.Math == Math && it;
};

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
module.exports =
  // eslint-disable-next-line no-undef
  check(typeof globalThis == 'object' && globalThis) ||
  check(typeof window == 'object' && window) ||
  check(typeof self == 'object' && self) ||
  check(typeof global == 'object' && global) ||
  // eslint-disable-next-line no-new-func
  Function('return this')();

/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(145)))

/***/ }),
/* 9 */
/***/ (function(module, exports) {

module.exports = {};


/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(8);
var shared = __webpack_require__(74);
var has = __webpack_require__(16);
var uid = __webpack_require__(64);
var NATIVE_SYMBOL = __webpack_require__(76);
var USE_SYMBOL_AS_UID = __webpack_require__(106);

var WellKnownSymbolsStore = shared('wks');
var Symbol = global.Symbol;
var createWellKnownSymb