@seafile/sea-email-editor 0.0.1

package/dist/intl/ReactIntlUniversal.js

@@ -0,0 +1,310 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _intlMessageformat = _interopRequireDefault(require("intl-messageformat"));
+var _escapeHtml = _interopRequireDefault(require("escape-html"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _lodash = _interopRequireDefault(require("lodash.merge"));
+var constants = _interopRequireWildcard(require("./constants"));
+if (!String.prototype.defaultMessage) {
+  const defaultMessage = function (msg) {
+    return this || msg || '';
+  };
+  // eslint-disable-next-line no-extend-native
+  String.prototype.defaultMessage = defaultMessage;
+  // eslint-disable-next-line no-extend-native
+  String.prototype.d = defaultMessage;
+}
+class ReactIntlUniversal {
+  constructor() {
+    this.options = {
+      currentLocale: null,
+      // Current locale such as 'en-US'
+      locales: {},
+      // app locale data like { "en-US": { "key1": "value1" }, "zh-CN": { "key1": "值1" } }
+      // eslint-disable-next-line
+      warningHandler: function () {
+        return console.warn(...arguments);
+      },
+      // ability to accumulate missing messages using third party services
+      escapeHtml: true,
+      // disable escape html in variable mode
+      fallbackLocale: null,
+      // Locale to use if a key is not found in the current locale
+      debug: false,
+      // If debugger mode is on, the message will be wrapped by a span
+      dataKey: 'data-i18n-key' // If debugger mode is on, the message will be wrapped by a span with this data key
+    };
+  }
+
+  /**
+   * Get the formatted message by key
+   * @param {string} key The string representing key in locale data file
+   * @param {Object} variables Variables in message
+   * @returns {string} message
+   */
+  _getFormattedMessage(key, variables) {
+    if (this.options.intlGetHook) {
+      try {
+        this.options.intlGetHook(key, this.options.currentLocale);
+      } catch (e) {
+        // eslint-disable-next-line
+        console.log('intl get hook error: ', e);
+      }
+    }
+    (0, _invariant.default)(key, 'key is required');
+    const {
+      locales,
+      currentLocale,
+      formats
+    } = this.options;
+
+    // 1. check if the locale data and key exists
+    if (!locales || !locales[currentLocale]) {
+      let errorMsg = `react-intl-universal locales data "${currentLocale}" not exists.`;
+      if (!currentLocale) {
+        errorMsg += ' More info: https://github.com/alibaba/react-intl-universal/issues/144#issuecomment-1345193138';
+      }
+      this.options.warningHandler(errorMsg);
+      return '';
+    }
+    let msg = this.getDescendantProp(locales[currentLocale], key);
+    if (msg == null) {
+      if (this.options.fallbackLocale) {
+        msg = this.getDescendantProp(locales[this.options.fallbackLocale], key);
+        if (msg == null) {
+          this.options.warningHandler(`react-intl-universal key "${key}" not defined in ${currentLocale} or the fallback locale, ${this.options.fallbackLocale}`);
+          return '';
+        }
+      } else {
+        this.options.warningHandler(`react-intl-universal key "${key}" not defined in ${currentLocale}`);
+        return '';
+      }
+    }
+
+    // 2. handle security issue for variables
+    if (variables) {
+      variables = Object.assign({}, variables);
+      // HTML message with variables. Escape it to avoid XSS attack.
+      for (let i in variables) {
+        let value = variables[i];
+        if (this.options.escapeHtml === true && (typeof value === 'string' || value instanceof String) && value.indexOf('<') >= 0) {
+          value = (0, _escapeHtml.default)(value);
+        }
+        variables[i] = value;
+      }
+    }
+
+    // 3. resolve variables
+    try {
+      let finalMsg;
+      if (variables) {
+        // format message with variables
+        const msgFormatter = new _intlMessageformat.default(msg, currentLocale, formats);
+        finalMsg = msgFormatter.format(variables);
+      } else {
+        // no variables, just return the message
+        finalMsg = msg;
+      }
+      return finalMsg;
+    } catch (err) {
+      this.options.warningHandler(`react-intl-universal format message failed for key='${key}'.`, err.message);
+      return msg;
+    }
+  }
+
+  /**
+   * Get the formatted message by key
+   * @param {string} key The string representing key in locale data file
+   * @param {Object} [variables] Variables in message
+   * @returns {string} message
+   */
+  get(key, variables) {
+    const msg = this._getFormattedMessage(key, variables);
+    return this.options.debug ? this._getSpanElementMessage(key, msg) : msg;
+  }
+
+  /**
+   * Get the formatted html message by key.
+   * @param {string} key The string representing key in locale data file
+   * @param {Object} [variables] Variables in message
+   * @returns {React.ReactElement} html message
+  */
+  getHTML(key, variables) {
+    let msg = this._getFormattedMessage(key, variables);
+    if (msg) {
+      return this._getSpanElementMessage(key, msg);
+    }
+    return '';
+  }
+
+  /**
+   * As same as get(...) API
+   * @param {Object} options
+   * @param {string} options.id
+   * @param {string} options.defaultMessage
+   * @param {Object} variables Variables in message
+   * @returns {string} message
+  */
+  formatMessage(messageDescriptor, variables) {
+    const {
+      id,
+      defaultMessage
+    } = messageDescriptor;
+    return this.get(id, variables).defaultMessage(defaultMessage);
+  }
+
+  /**
+   * As same as getHTML(...) API
+   * @param {Object} options
+   * @param {string} options.id
+   * @param {React.Element} options.defaultMessage
+   * @param {Object} variables Variables in message
+   * @returns {React.Element} message
+  */
+  formatHTMLMessage(messageDescriptor, variables) {
+    const {
+      id,
+      defaultMessage
+    } = messageDescriptor;
+    return this.getHTML(id, variables).defaultMessage(defaultMessage);
+  }
+
+  /**
+   * Helper: determine user's locale via URL, cookie, localStorage, and browser's language.
+   * You may not need this API, if you have other rules to determine user's locale.
+   * @param {string} options.urlLocaleKey URL's query Key to determine locale. Example: if URL=http://localhost?lang=en-US, then set it 'lang'
+   * @param {string} options.cookieLocaleKey Cookie's Key to determine locale. Example: if cookie=lang:en-US, then set it 'lang'
+   * @param {string} options.localStorageLocaleKey LocalStorage's Key to determine locale such as 'lang'
+   * @returns {string} determined locale such as 'en-US'
+   */
+  determineLocale() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return this.getLocaleFromURL(options) || this.getLocaleFromCookie(options) || this.getLocaleFromLocalStorage(options) || this.getLocaleFromBrowser();
+  }
+
+  /**
+   * Change current locale
+   * @param {string} newLocale Current locale such as 'en-US'
+   */
+  changeCurrentLocale(newLocale) {
+    if (!this.options.locales || !this.options.locales[newLocale]) {
+      let errorMsg = `react-intl-universal locales data "${newLocale}" not exists.`;
+      if (!this.options.locales) {
+        errorMsg += 'You should call init function first.';
+      }
+      this.options.warningHandler(errorMsg);
+      return;
+    }
+    this.options.currentLocale = newLocale;
+  }
+
+  /**
+   * Initialize properties and load CLDR locale data according to currentLocale
+   * @param {Object} options
+   * @param {string} options.currentLocale Current locale such as 'en-US'
+   * @param {any} options.locales App locale data like {"en-US":{"key1":"value1"},"zh-CN":{"key1":"值1"}}
+   * @param {boolean} [options.debug] debug mode
+   * @returns {Promise}
+   */
+  init() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _invariant.default)(options.currentLocale, 'options.currentLocale is required');
+    (0, _invariant.default)(options.locales, 'options.locales is required');
+    Object.assign(this.options, options);
+    this.options.formats = Object.assign({}, this.options.formats, constants.defaultFormats);
+    return new Promise((resolve, reject) => {
+      // init() will not load external common locale data anymore.
+      // But, it still return a Promise for backward compatibility.
+      resolve();
+    });
+  }
+
+  /**
+   * Get the inital options
+   */
+  getInitOptions() {
+    return this.options;
+  }
+
+  /**
+   * Load more locales after init
+   */
+  load(locales) {
+    (0, _lodash.default)(this.options.locales, locales);
+  }
+  getLocaleFromCookie(options) {
+    const {
+      cookieLocaleKey
+    } = options;
+    if (cookieLocaleKey && typeof document !== 'undefined') {
+      const cookies = document.cookie.split(';'); // Split on semicolon only
+      const cookieObj = {};
+      cookies.forEach(cookie => {
+        const [key, value] = cookie.trim().split('='); // Trim leading/trailing spaces
+        if (key) {
+          cookieObj[key] = decodeURIComponent(value); // cookie values may be URL-encoded
+        }
+      });
+      return cookieObj[cookieLocaleKey];
+    }
+  }
+  getLocaleFromLocalStorage(options) {
+    const {
+      localStorageLocaleKey
+    } = options;
+    if (localStorageLocaleKey && window.localStorage) {
+      return localStorage.getItem(localStorageLocaleKey);
+    }
+  }
+  getLocaleFromURL(options) {
+    const {
+      urlLocaleKey
+    } = options;
+    if (urlLocaleKey) {
+      let query = window.location.search.split('?');
+      if (query.length >= 2) {
+        const params = new URLSearchParams(query[1]);
+        if (params.has(urlLocaleKey)) {
+          return params.get(urlLocaleKey);
+        }
+      }
+    }
+  }
+  getDescendantProp(locale, key) {
+    if (locale[key]) {
+      return locale[key];
+    }
+    const msg = key.split('.').reduce(function (a, b) {
+      return a !== undefined ? a[b] : a;
+    }, locale);
+    return msg;
+  }
+  getLocaleFromBrowser() {
+    return navigator.language || navigator.userLanguage;
+  }
+  _getSpanElementMessage(key, msg) {
+    const options = {
+      dangerouslySetInnerHTML: {
+        __html: msg
+      }
+    };
+    if (this.options.debug) {
+      options[this.options.dataKey] = key;
+    }
+    const el = /*#__PURE__*/_react.default.createElement('span', options);
+    // when key exists, it should still return element if there's defaultMessage() after getHTML()
+    const defaultMessage = () => el;
+    return Object.assign({
+      defaultMessage: defaultMessage,
+      d: defaultMessage
+    }, el);
+  }
+}
+var _default = exports.default = ReactIntlUniversal;

package/dist/intl/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultFormats = void 0;
+/**
+ * Currency code list
+ * https://www.currency-iso.org/en/home/tables/table-a1.html
+ */
+const currency = ['AFN', 'EUR', 'ALL', 'DZD', 'USD', 'AOA', 'XCD', 'ARS', 'AMD', 'AWG', 'AUD', 'AZN', 'BSD', 'BHD', 'BDT', 'BBD', 'BYN', 'BZD', 'XOF', 'BMD', 'INR', 'BTN', 'BOB', 'BOV', 'BAM', 'BWP', 'NOK', 'BRL', 'BND', 'BGN', 'BIF', 'CVE', 'KHR', 'XAF', 'CAD', 'KYD', 'CLP', 'CLF', 'CNY', 'COP', 'COU', 'KMF', 'CDF', 'NZD', 'CRC', 'HRK', 'CUP', 'CUC', 'ANG', 'CZK', 'DKK', 'DJF', 'DOP', 'EGP', 'SVC', 'ERN', 'ETB', 'FKP', 'FJD', 'XPF', 'GMD', 'GEL', 'GHS', 'GIP', 'GTQ', 'GBP', 'GNF', 'GYD', 'HTG', 'HNL', 'HKD', 'HUF', 'ISK', 'IDR', 'XDR', 'IRR', 'IQD', 'ILS', 'JMD', 'JPY', 'JOD', 'KZT', 'KES', 'KPW', 'KRW', 'KWD', 'KGS', 'LAK', 'LBP', 'LSL', 'ZAR', 'LRD', 'LYD', 'CHF', 'MOP', 'MKD', 'MGA', 'MWK', 'MYR', 'MVR', 'MRO', 'MUR', 'XUA', 'MXN', 'MXV', 'MDL', 'MNT', 'MAD', 'MZN', 'MMK', 'NAD', 'NPR', 'NIO', 'NGN', 'OMR', 'PKR', 'PAB', 'PGK', 'PYG', 'PEN', 'PHP', 'PLN', 'QAR', 'RON', 'RUB', 'RWF', 'SHP', 'WST', 'STD', 'SAR', 'RSD', 'SCR', 'SLL', 'SGD', 'XSU', 'SBD', 'SOS', 'SSP', 'LKR', 'SDG', 'SRD', 'SZL', 'SEK', 'CHE', 'CHW', 'SYP', 'TWD', 'TJS', 'TZS', 'THB', 'TOP', 'TTD', 'TND', 'TRY', 'TMT', 'UGX', 'UAH', 'AED', 'USN', 'UYU', 'UYI', 'UZS', 'VUV', 'VEF', 'VND', 'YER', 'ZMW', 'ZWL', 'XBA', 'XBB', 'XBC', 'XBD', 'XTS', 'XXX', 'XAU', 'XPD', 'XPT', 'XAG'];
+const numberFormat = {};
+for (var i = 0; i < currency.length; i++) {
+  numberFormat[currency[i]] = {
+    style: 'currency',
+    currency: currency[i]
+  };
+}
+const defaultFormats = exports.defaultFormats = {
+  number: numberFormat
+};

package/dist/intl/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ReactIntlUniversal", {
+  enumerable: true,
+  get: function () {
+    return _ReactIntlUniversal.default;
+  }
+});
+exports.load = exports.init = exports.getLocaleFromURL = exports.getLocaleFromLocalStorage = exports.getLocaleFromCookie = exports.getLocaleFromBrowser = exports.getInitOptions = exports.getHTML = exports.getDescendantProp = exports.get = exports.formatMessage = exports.formatHTMLMessage = exports.determineLocale = exports.default = exports.changeCurrentLocale = void 0;
+var _ReactIntlUniversal = _interopRequireDefault(require("./ReactIntlUniversal"));
+const defaultInstance = exports.default = new _ReactIntlUniversal.default();
+// resolved by CommonJS module loader
+defaultInstance.ReactIntlUniversal = _ReactIntlUniversal.default;
+// react pattern: https://github.com/facebook/react/blob/main/packages/react/src/React.js
+const get = exports.get = defaultInstance.get.bind(defaultInstance);
+const getHTML = exports.getHTML = defaultInstance.getHTML.bind(defaultInstance);
+const formatMessage = exports.formatMessage = defaultInstance.formatMessage.bind(defaultInstance);
+const formatHTMLMessage = exports.formatHTMLMessage = defaultInstance.formatHTMLMessage.bind(defaultInstance);
+const determineLocale = exports.determineLocale = defaultInstance.determineLocale.bind(defaultInstance);
+const changeCurrentLocale = exports.changeCurrentLocale = defaultInstance.changeCurrentLocale.bind(defaultInstance);
+const init = exports.init = defaultInstance.init.bind(defaultInstance);
+const getInitOptions = exports.getInitOptions = defaultInstance.getInitOptions.bind(defaultInstance);
+const load = exports.load = defaultInstance.load.bind(defaultInstance);
+const getLocaleFromCookie = exports.getLocaleFromCookie = defaultInstance.getLocaleFromCookie.bind(defaultInstance);
+const getLocaleFromLocalStorage = exports.getLocaleFromLocalStorage = defaultInstance.getLocaleFromLocalStorage.bind(defaultInstance);
+const getLocaleFromURL = exports.getLocaleFromURL = defaultInstance.getLocaleFromURL.bind(defaultInstance);
+const getDescendantProp = exports.getDescendantProp = defaultInstance.getDescendantProp.bind(defaultInstance);
+const getLocaleFromBrowser = exports.getLocaleFromBrowser = defaultInstance.getLocaleFromBrowser.bind(defaultInstance);
+// resolved by ECMAScript module loader

package/dist/locale/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LOCALES = void 0;
+var _en = _interopRequireDefault(require("./lang/en.json"));
+const LOCALES = exports.LOCALES = {
+  'en': _en.default
+};

package/dist/locale/lang/en.json

@@ -0,0 +1,83 @@
+{
+  "Bold": "Bold",
+  "Italic": "Italic",
+  "Code": "Code",
+  "Header one": "Heading 1",
+  "Header two": "Heading 2",
+  "Header three": "Heading 3",
+  "Header four": "Heading 4",
+  "Header five": "Heading 5",
+  "Header six": "Heading 6",
+  "Paragraph": "Paragraph",
+  "Quote": "Quote",
+  "Ordered list": "Ordered list",
+  "Unordered list": "Unordered list",
+  "Check list item": "Check list item",
+  "Insert image": "Insert image",
+  "Insert formula": "Insert formula",
+  "Formula": "Formula",
+  "Inline code": "Inline code",
+  "Code block": "Code block",
+  "Insert link": "Insert link",
+  "Insert table": "Insert table",
+  "Save": "Save",
+  "Invalid url": "Invalid URL",
+  "Link address": "Link address",
+  "Image address": "Image address",
+  "Submit": "Submit",
+  "Cancel": "Cancel",
+  "Help": "Help",
+  "Delete table": "Delete table",
+  "Column": "Column",
+  "Row": "Row",
+  "Insert row before": "Insert row before",
+  "Insert row after": "Insert row after",
+  "Insert column before": "Insert column before",
+  "Insert column after": "Insert column after",
+  "Delete row": "Delete row",
+  "Delete column": "Delete column",
+  "Insert row": "Insert row",
+  "Insert column": "Insert column",
+  "Set align": "Set align",
+  "Left": "Left",
+  "Center": "Center",
+  "Right": "Right",
+  "Edit": "Edit",
+  "Copy": "Copy",
+  "Copied": "Copied",
+  "Internal link": "Internal link",
+  "Copy_internal link": "Internal link has been copied to clipboard",
+  "Internal link desc": "An internal link is a link to a file or folder that can be accessed by users with read permission to the file or folder.",
+  "Insert network image": "Insert network image",
+  "Upload local image": "Upload local image",
+  "Add link": "Add link",
+  "Link title": "Link title",
+  "Delete": "Delete",
+  "Empty": "Empty",
+  "Width": "Width",
+  "Height": "Height",
+  "Full screen": "Full screen",
+  "Size": "Size",
+  "Clear format": "Clear format",
+  "Image address invalid": "Image address invalid",
+  "Link address required": "Link address required",
+  "Link address invalid": "Link address invalid",
+  "Link title required": "Link title required",
+  "Blank title not allowed": "Blank title not allowed",
+  "Font_style": "Font style",
+  "Open link": "Open link",
+  "Image is uploading": "Image is uploading",
+  "Image loading failed": "Image loading failed",
+  "Insert below": "Insert below",
+  "Insert above": "Insert above",
+  "Insert on the right": "Insert on the right",
+  "Insert on the left": "Insert on the left",
+  "Row(s)": "row(s)",
+  "Column(s)": "column(s)",
+  "Insert": "Insert",
+  "Horizontal align": "Horizontal align",
+  "Underline": "Underline",
+  "Row number": "Row number",
+  "Column number": "Column number",
+  "Copy link": "Copy link"
+}

package/dist/slate-convert/html-to-slate/constants.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BLOCKQUOTE", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.BLOCKQUOTE;
+  }
+});
+Object.defineProperty(exports, "BR", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.BR;
+  }
+});
+Object.defineProperty(exports, "CHECK_LIST_ITEM", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.CHECK_LIST_ITEM;
+  }
+});
+Object.defineProperty(exports, "CODE_BLOCK", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.CODE_BLOCK;
+  }
+});
+Object.defineProperty(exports, "CODE_LINE", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.CODE_LINE;
+  }
+});
+Object.defineProperty(exports, "HEADER1", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER1;
+  }
+});
+Object.defineProperty(exports, "HEADER2", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER2;
+  }
+});
+Object.defineProperty(exports, "HEADER3", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER3;
+  }
+});
+Object.defineProperty(exports, "HEADER4", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER4;
+  }
+});
+Object.defineProperty(exports, "HEADER5", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER5;
+  }
+});
+Object.defineProperty(exports, "HEADER6", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.HEADER6;
+  }
+});
+exports.HEADER_TYPE_MAP = exports.HEADER_LIST = void 0;
+Object.defineProperty(exports, "IMAGE", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.IMAGE;
+  }
+});
+exports.INLINE_LEVEL_TYPES = void 0;
+Object.defineProperty(exports, "LINK", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.LINK;
+  }
+});
+Object.defineProperty(exports, "LIST_ITEM", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.LIST_ITEM;
+  }
+});
+Object.defineProperty(exports, "ORDERED_LIST", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.ORDERED_LIST;
+  }
+});
+Object.defineProperty(exports, "P", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.P;
+  }
+});
+Object.defineProperty(exports, "PARAGRAPH", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.PARAGRAPH;
+  }
+});
+Object.defineProperty(exports, "TABLE", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.TABLE;
+  }
+});
+Object.defineProperty(exports, "TABLE_CELL", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.TABLE_CELL;
+  }
+});
+Object.defineProperty(exports, "TABLE_ROW", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.TABLE_ROW;
+  }
+});
+exports.TOP_LEVEL_TYPES = void 0;
+Object.defineProperty(exports, "UNORDERED_LIST", {
+  enumerable: true,
+  get: function () {
+    return _elementTypes.UNORDERED_LIST;
+  }
+});
+var _elementTypes = require("../../extension/constants/element-types");
+const TOP_LEVEL_TYPES = exports.TOP_LEVEL_TYPES = [_elementTypes.BLOCKQUOTE, _elementTypes.HEADER1, _elementTypes.HEADER2, _elementTypes.HEADER3, _elementTypes.HEADER4, _elementTypes.HEADER5, _elementTypes.HEADER6, _elementTypes.ORDERED_LIST, _elementTypes.UNORDERED_LIST, _elementTypes.CHECK_LIST_ITEM, _elementTypes.PARAGRAPH, _elementTypes.CODE_BLOCK, _elementTypes.TABLE];
+const INLINE_LEVEL_TYPES = exports.INLINE_LEVEL_TYPES = [_elementTypes.IMAGE, _elementTypes.LINK];
+const HEADER_LIST = exports.HEADER_LIST = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];
+const HEADER_TYPE_MAP = exports.HEADER_TYPE_MAP = {
+  H1: _elementTypes.HEADER1,
+  H2: _elementTypes.HEADER2,
+  H3: _elementTypes.HEADER3,
+  H4: _elementTypes.HEADER4,
+  H5: _elementTypes.HEADER5,
+  H6: _elementTypes.HEADER6
+};