403Webshell
Server IP : 80.87.202.40  /  Your IP : 216.73.216.169
Web Server : Apache
System : Linux rospirotorg.ru 5.14.0-539.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Dec 5 22:26:13 UTC 2024 x86_64
User : bitrix ( 600)
PHP Version : 8.2.27
Disable Function : NONE
MySQL : OFF |  cURL : ON |  WGET : ON |  Perl : ON |  Python : OFF |  Sudo : ON |  Pkexec : ON
Directory :  /home/bitrix/ext_www/rospirotorg.ru/bitrix/js/ui/text-editor/dist/

Upload File :
current_dir [ Writeable] document_root [ Writeable]

 

Command :


[ Back ]     

Current File : /home/bitrix/ext_www/rospirotorg.ru/bitrix/js/ui/text-editor/dist/text-editor.bundle.js
/* eslint-disable */
this.BX = this.BX || {};
this.BX.UI = this.BX.UI || {};
(function (exports,ui_codeParser,ui_bbcode_parser,ui_textEditor,ui_lexical_clipboard,ui_smiley,ui_videoService,main_core_collections,ui_bbcode_model,ui_lexical_selection,ui_lexical_richText,ui_lexical_table,main_core_events,ui_lexical_history,main_popup,main_core_cache,ui_iconSet_editor,ui_lexical_list,ui_lexical_link,ui_lexical_text,ui_lexical_core,ui_lexical_utils,main_core) {
	'use strict';

	const HIDE_DIALOG_COMMAND = ui_lexical_core.createCommand('HIDE_DIALOG_COMMAND');
	const DIALOG_VISIBILITY_COMMAND = ui_lexical_core.createCommand('DIALOG_VISIBILITY_COMMAND');
	const DRAG_START_COMMAND = ui_lexical_core.createCommand('DRAG_START_COMMAND');
	const DRAG_END_COMMAND = ui_lexical_core.createCommand('DRAG_END_COMMAND');

	var AllCommands = /*#__PURE__*/Object.freeze({
		HIDE_DIALOG_COMMAND: HIDE_DIALOG_COMMAND,
		DIALOG_VISIBILITY_COMMAND: DIALOG_VISIBILITY_COMMAND,
		DRAG_START_COMMAND: DRAG_START_COMMAND,
		DRAG_END_COMMAND: DRAG_END_COMMAND
	});

	// Node flags
	const UNFORMATTED = 1;
	const NewLineMode = {
	  LINE_BREAK: 'line-break',
	  PARAGRAPH: 'paragraph',
	  MIXED: 'mixed'
	};

	var AllConstants = /*#__PURE__*/Object.freeze({
		UNFORMATTED: UNFORMATTED,
		NewLineMode: NewLineMode
	});

	const NON_SINGLE_WIDTH_CHARS_REPLACEMENT = Object.freeze({
	  '\t': '\\t',
	  '\n': '\\n'
	});
	const NON_SINGLE_WIDTH_CHARS_REGEX = new RegExp(Object.keys(NON_SINGLE_WIDTH_CHARS_REPLACEMENT).join('|'), 'g');
	const SYMBOLS = Object.freeze({
	  ancestorHasNextSibling: '|',
	  ancestorIsLastChild: ' ',
	  hasNextSibling: '├',
	  isLastChild: '└',
	  selectedChar: '^',
	  selectedLine: '>'
	});
	const FORMAT_PREDICATES = [node => node.hasFormat('bold') && 'Bold', node => node.hasFormat('code') && 'Code', node => node.hasFormat('italic') && 'Italic', node => node.hasFormat('strikethrough') && 'Strikethrough', node => node.hasFormat('subscript') && 'Subscript', node => node.hasFormat('superscript') && 'Superscript', node => node.hasFormat('underline') && 'Underline'];
	const DETAIL_PREDICATES = [node => node.isDirectionless() && 'Directionless', node => node.isUnmergeable() && 'Unmergeable'];
	const MODE_PREDICATES = [node => node.isToken() && 'Token', node => node.isSegmented() && 'Segmented'];

	function getSelectedNode(selection) {
	  const anchor = selection.anchor;
	  const focus = selection.focus;
	  const anchorNode = selection.anchor.getNode();
	  const focusNode = selection.focus.getNode();
	  if (anchorNode === focusNode) {
	    return anchorNode;
	  }
	  const isBackward = selection.isBackward();
	  if (isBackward) {
	    return ui_lexical_selection.$isAtNodeEnd(focus) ? anchorNode : focusNode;
	  }
	  return ui_lexical_selection.$isAtNodeEnd(anchor) ? anchorNode : focusNode;
	}

	const nodeNameToTextFormat = {
	  b: 'bold',
	  strong: 'bold',
	  i: 'italic',
	  em: 'italic',
	  s: 'strikethrough',
	  del: 'strikethrough',
	  u: 'underline',
	  sub: 'subscript',
	  sup: 'superscript'
	};
	function convertTextFormatElement(node) {
	  const format = nodeNameToTextFormat[node.getName()];
	  if (format === undefined) {
	    return {
	      node: null
	    };
	  }
	  return {
	    forChild: lexicalNode => {
	      if (ui_lexical_core.$isTextNode(lexicalNode) && !lexicalNode.hasFormat(format)) {
	        lexicalNode.toggleFormat(format);
	      }
	      return lexicalNode;
	    },
	    node: null
	  };
	}

	function $importFromBBCode(bbcode, editor, normalize = true) {
	  const scheme = editor.getBBCodeScheme();
	  const parser = new ui_bbcode_parser.BBCodeParser({
	    scheme
	  });
	  const ast = parser.parse(bbcode);
	  const elements = ast.getChildren();

	  // console.log(ast);

	  let lexicalNodes = [];
	  for (const element of elements) {
	    const nodes = $createNodesFromBBCode(element, editor);
	    if (nodes !== null) {
	      lexicalNodes = [...lexicalNodes, ...nodes];
	    }
	  }
	  return normalize ? $normalizeTextNodes(lexicalNodes) : lexicalNodes;
	}
	function $createNodesFromBBCode(node, editor, forChildMap = new Map(), parentLexicalNode = null) {
	  if (node instanceof ui_bbcode_model.BBCodeNewLineNode) {
	    return [ui_lexical_core.$createLineBreakNode()];
	  }
	  if (node instanceof ui_bbcode_model.BBCodeTabNode) {
	    return [ui_lexical_core.$createTabNode()];
	  }
	  let lexicalNodes = [];
	  let currentLexicalNode = null;
	  const transformFunction = getConversionFunction(node, editor);
	  const transformOutput = transformFunction ? transformFunction(node) : null;
	  let postTransform = null;
	  if (transformOutput !== null) {
	    postTransform = transformOutput.after;
	    const transformNodes = transformOutput.node;
	    currentLexicalNode = Array.isArray(transformNodes) ? transformNodes[transformNodes.length - 1] : transformNodes;
	    if (currentLexicalNode !== null) {
	      for (const [, forChildFunction] of forChildMap) {
	        currentLexicalNode = forChildFunction(currentLexicalNode, parentLexicalNode);
	        if (!currentLexicalNode) {
	          break;
	        }
	      }
	      if (currentLexicalNode) {
	        lexicalNodes.push(...(Array.isArray(transformNodes) ? transformNodes : [currentLexicalNode]));
	      }
	    }
	    if (main_core.Type.isFunction(transformOutput.forChild)) {
	      forChildMap.set(node.getName(), transformOutput.forChild);
	    }
	  }
	  const children = node.getChildren();
	  let childLexicalNodes = [];
	  for (const child of children) {
	    childLexicalNodes.push(...$createNodesFromBBCode(child, editor, new Map(forChildMap), currentLexicalNode));
	  }
	  if (main_core.Type.isFunction(postTransform)) {
	    childLexicalNodes = postTransform(childLexicalNodes);
	  }

	  // Unknown node
	  if (transformOutput === null) {
	    if (node.getType() === ui_bbcode_model.BBCodeNode.ELEMENT_NODE) {
	      const elementNode = node;
	      if (elementNode.isVoid()) {
	        childLexicalNodes = [ui_lexical_core.$createTextNode(elementNode.getOpeningTag()), ...childLexicalNodes];
	      } else {
	        childLexicalNodes = [ui_lexical_core.$createTextNode(elementNode.getOpeningTag()), ...childLexicalNodes, ui_lexical_core.$createTextNode(elementNode.getClosingTag())];
	      }
	    } else {
	      childLexicalNodes = [ui_lexical_core.$createTextNode(node.toString()), ...childLexicalNodes];
	    }
	  }
	  if (currentLexicalNode === null) {
	    // If it hasn't been converted to a LexicalNode, we hoist its children
	    // up to the same level as it.
	    lexicalNodes = [...lexicalNodes, ...childLexicalNodes];
	  } else if (ui_lexical_core.$isElementNode(currentLexicalNode)) {
	    // If the current node is a ElementNode after conversion,
	    // we can append all the children to it.
	    currentLexicalNode.append(...childLexicalNodes);
	  }
	  return lexicalNodes;
	}
	function shouldWrapInParagraph(lexicalNode) {
	  if (ui_lexical_core.$isElementNode(lexicalNode) && lexicalNode.isInline() === false) {
	    return false;
	  }
	  return !(ui_lexical_core.$isDecoratorNode(lexicalNode) && lexicalNode.isInline() === false);
	}
	function $normalizeTextNodes(lexicalNodes) {
	  const result = [];
	  let currentParagraph = null;
	  let lineBreaks = 0;
	  for (const lexicalNode of lexicalNodes) {
	    if (ui_lexical_core.$isLineBreakNode(lexicalNode)) {
	      lineBreaks++;
	      continue;
	    }
	    if (shouldWrapInParagraph(lexicalNode)) {
	      if (currentParagraph === null || lineBreaks >= 2) {
	        result.push(...$createEmptyParagraphs(lineBreaks - 2));
	        currentParagraph = ui_lexical_core.$createParagraphNode();
	        result.push(currentParagraph);
	      } else if (lineBreaks === 1) {
	        currentParagraph.append(ui_lexical_core.$createLineBreakNode());
	      }
	      currentParagraph.append(lexicalNode);
	    } else {
	      if (lineBreaks > 2) {
	        result.push(...$createEmptyParagraphs(lineBreaks - 2));
	      }
	      result.push(lexicalNode);
	      currentParagraph = null;
	    }
	    lineBreaks = 0;
	  }
	  if (result.length === 0) {
	    return [ui_lexical_core.$createParagraphNode()];
	  }
	  return result;
	}
	function $createEmptyParagraphs(count = 1) {
	  const result = [];
	  for (let i = 0; i < count; i++) {
	    result.push(ui_lexical_core.$createParagraphNode());
	  }
	  return result;
	}
	function getConversionFunction(node, editor) {
	  const nodeName = node.getName();
	  let currentConversion = null;
	  const importMap = editor.getBBCodeImportMap();
	  const conversions = importMap.get(nodeName.toLowerCase());
	  if (conversions !== undefined) {
	    for (const conversion of conversions) {
	      const bbCodeConversion = conversion(node);
	      if (bbCodeConversion !== null && (currentConversion === null || currentConversion.priority < bbCodeConversion.priority)) {
	        currentConversion = bbCodeConversion;
	      }
	    }
	  }
	  if (currentConversion === null) {
	    if (nodeName === '#text') {
	      return convertTextNode;
	    }
	    return null;
	  }
	  return currentConversion.conversion;
	}
	function convertTextNode(textNode) {
	  let textContent = textNode.getContent();
	  textContent = textContent.replaceAll(/\r?\n|\t/gm, ' ').replace('\r', '');
	  if (textContent === '') {
	    return {
	      node: null
	    };
	  }
	  return {
	    node: ui_lexical_core.$createTextNode(textContent)
	  };
	}

	function $isParagraphEmpty(node) {
	  if (!ui_lexical_core.$isParagraphNode(node)) {
	    return false;
	  }
	  if (node.isEmpty()) {
	    return true;
	  }
	  return node.getChildren().every(child => {
	    return ui_lexical_core.$isLineBreakNode(child) || ui_lexical_core.$isTextNode(child) && /^\s*$/.test(child.getTextContent());
	  });
	}

	function trimEmptyParagraphs(nodes) {
	  const trimmedNodes = [...nodes];

	  // trim from the start
	  while (trimmedNodes.length > 0 && $isParagraphEmpty(trimmedNodes[0])) {
	    trimmedNodes.splice(0, 1);
	  }

	  // trim from the end
	  while (trimmedNodes.length > 0 && $isParagraphEmpty(trimmedNodes[trimmedNodes.length - 1])) {
	    trimmedNodes.splice(-1, 1);
	  }
	  return trimmedNodes;
	}

	/* eslint-disable @bitrix24/bitrix24-rules/no-native-dom-methods */
	function $exportToBBCode(lexicalNode, editor) {
	  const scheme = editor.getBBCodeScheme();
	  const root = scheme.createRoot();
	  const topLevelChildren = trimEmptyParagraphs(lexicalNode.getChildren());
	  for (const topLevelNode of topLevelChildren) {
	    $appendNodesToBBCode(topLevelNode, root, editor);
	    // root.appendChild(scheme.createNewLine());
	  }

	  return root;
	}
	function $appendNodesToBBCode(currentNode, parentNode, editor) {
	  const {
	    node,
	    after
	  } = getExportFunction(currentNode, editor);
	  if (!node) {
	    return;
	  }
	  const scheme = editor.getBBCodeScheme();
	  const fragment = scheme.createFragment();
	  const children = ui_lexical_core.$isElementNode(currentNode) ? currentNode.getChildren() : [];
	  for (const childNode of children) {
	    $appendNodesToBBCode(childNode, fragment, editor);
	  }
	  node.appendChild(fragment);
	  parentNode.appendChild(node);
	  if (main_core.Type.isFunction(after)) {
	    const newElement = after.call(currentNode, node);
	    if (newElement) {
	      node.getParent().replaceChild(node, newElement);
	    }
	  }
	}
	const formats = ['bold', 'italic', 'strikethrough', 'underline'];
	function getExportFunction(lexicalNode, editor) {
	  const type = lexicalNode.getType();
	  const exportMap = editor.getBBCodeExportMap();
	  const exportFn = exportMap.get(type);
	  if (main_core.Type.isFunction(exportFn)) {
	    return exportFn(lexicalNode);
	  }
	  const scheme = editor.getBBCodeScheme();
	  if (ui_lexical_core.$isTextNode(lexicalNode) && lexicalNode.getType() === 'text') {
	    const node = scheme.createText({
	      encode: false,
	      content: lexicalNode.getTextContent()
	    });
	    if (lexicalNode.getFormat() === 0) {
	      return {
	        node
	      };
	    }
	    let currentNode = node;
	    formats.forEach(format => {
	      const formatFn = exportMap.get(`text:${format}`);
	      if (main_core.Type.isFunction(formatFn)) {
	        currentNode = formatFn(lexicalNode, currentNode) || currentNode;
	      }
	    });
	    return {
	      node: currentNode
	    };
	  }
	  if (ui_lexical_core.$isLineBreakNode(lexicalNode)) {
	    return {
	      node: scheme.createNewLine()
	    };
	  }
	  if (ui_lexical_core.$isTabNode(lexicalNode)) {
	    return {
	      node: scheme.createTab()
	    };
	  }
	  if (ui_lexical_core.$isTextNode(lexicalNode) || ui_lexical_core.$isElementNode(lexicalNode)) {
	    const node = scheme.createText({
	      encode: false,
	      content: lexicalNode.getTextContent()
	    });
	    return {
	      node
	    };
	  }
	  return {
	    node: null
	  };
	}

	/* eslint-disable @bitrix24/bitrix24-rules/no-native-dom-methods */
	function wrapNodeWith(node, tag, editor) {
	  const scheme = editor.getBBCodeScheme();
	  const elementNode = scheme.createElement({
	    name: tag
	  });
	  elementNode.appendChild(node);
	  return elementNode;
	}

	var _textEditor = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("textEditor");
	var _destroyed = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("destroyed");
	var _removeListeners = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("removeListeners");
	/**
	 * @memberof BX.UI.TextEditor
	 */
	class BasePlugin {
	  constructor(textEditor) {
	    Object.defineProperty(this, _textEditor, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _destroyed, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _removeListeners, {
	      writable: true,
	      value: () => {}
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _textEditor)[_textEditor] = textEditor;
	  }
	  static getName() {
	    throw new Error('getName must be implemented in a child class');
	  }
	  static getNodes(editor) {
	    return [];
	  }
	  importBBCode() {
	    return null;
	  }
	  exportBBCode() {
	    return null;
	  }
	  validateScheme() {
	    return null;
	  }
	  afterInit() {
	    // you can override this method
	  }
	  getName() {
	    return this.constructor.getName();
	  }
	  getEditor() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _textEditor)[_textEditor];
	  }
	  getLexicalEditor() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _textEditor)[_textEditor].getLexicalEditor();
	  }
	  cleanUpRegister(...func) {
	    babelHelpers.classPrivateFieldLooseBase(this, _removeListeners)[_removeListeners] = ui_lexical_utils.mergeRegister(babelHelpers.classPrivateFieldLooseBase(this, _removeListeners)[_removeListeners], ...func);
	  }
	  isDestroyed() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _destroyed)[_destroyed];
	  }
	  destroy() {
	    babelHelpers.classPrivateFieldLooseBase(this, _destroyed)[_destroyed] = true;
	    babelHelpers.classPrivateFieldLooseBase(this, _removeListeners)[_removeListeners]();
	    babelHelpers.classPrivateFieldLooseBase(this, _removeListeners)[_removeListeners] = null;
	  }
	}

	class ToolbarItem extends main_core_events.EventEmitter {
	  constructor() {
	    super();
	    this.setEventNamespace('BX.UI.TextEditor.ToolbarItem');
	  }
	  getContainer() {
	    throw new Error('You must implement getContainer() method.');
	  }
	  render() {
	    throw new Error('You must implement render() method.');
	  }
	}

	let _ = t => t,
	  _t;

	/**
	 * @memberof BX.UI.TextEditor
	 */
	var _format = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("format");
	var _blockType = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("blockType");
	var _active = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("active");
	var _disabled = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("disabled");
	var _disableInsideUnformatted = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("disableInsideUnformatted");
	var _disableCallback = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("disableCallback");
	var _container = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("container");
	var _handleClick = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleClick");
	class Button extends ToolbarItem {
	  constructor(...args) {
	    super(...args);
	    Object.defineProperty(this, _handleClick, {
	      value: _handleClick2
	    });
	    Object.defineProperty(this, _format, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _blockType, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _active, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _disabled, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _disableInsideUnformatted, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _disableCallback, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _container, {
	      writable: true,
	      value: null
	    });
	  }
	  setContent(content) {
	    if (main_core.Type.isString(content)) {
	      this.getContainer().innerHTML = content;
	    } else if (main_core.Type.isElementNode(content)) {
	      this.getContainer().append(content);
	    }
	  }
	  setFormat(format) {
	    babelHelpers.classPrivateFieldLooseBase(this, _format)[_format] = format;
	  }
	  getFormat() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _format)[_format];
	  }
	  hasFormat() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _format)[_format];
	  }
	  setBlockType(type) {
	    babelHelpers.classPrivateFieldLooseBase(this, _blockType)[_blockType] = type;
	  }
	  getBlockType() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _blockType)[_blockType];
	  }
	  setTooltip(tooltip) {
	    if (main_core.Type.isStringFilled(tooltip)) {
	      main_core.Dom.attr(this.getContainer(), 'title', main_core.Text.encode(tooltip));
	    } else if (tooltip === null) {
	      main_core.Dom.attr(this.getContainer(), 'title', null);
	    }
	  }
	  disableInsideUnformatted() {
	    babelHelpers.classPrivateFieldLooseBase(this, _disableInsideUnformatted)[_disableInsideUnformatted] = true;
	  }
	  enableInsideUnformatted() {
	    babelHelpers.classPrivateFieldLooseBase(this, _disableInsideUnformatted)[_disableInsideUnformatted] = false;
	  }
	  shouldDisableInsideUnformatted() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _disableInsideUnformatted)[_disableInsideUnformatted];
	  }
	  setActive(active = true) {
	    if (active === babelHelpers.classPrivateFieldLooseBase(this, _active)[_active]) {
	      return;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _active)[_active] = active;
	    if (active) {
	      main_core.Dom.addClass(this.getContainer(), '--active');
	    } else {
	      main_core.Dom.removeClass(this.getContainer(), '--active');
	    }
	  }
	  isActive() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _active)[_active];
	  }
	  setDisabled(disabled = true) {
	    if (disabled === babelHelpers.classPrivateFieldLooseBase(this, _disabled)[_disabled]) {
	      return;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _disabled)[_disabled] = disabled;
	    if (disabled) {
	      main_core.Dom.attr(this.getContainer(), {
	        disabled: true
	      });
	    } else {
	      main_core.Dom.attr(this.getContainer(), {
	        disabled: null
	      });
	    }
	  }
	  disable() {
	    this.setDisabled(true);
	  }
	  enable() {
	    this.setDisabled(false);
	  }
	  isDisabled() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _disabled)[_disabled];
	  }
	  hasOwnDisableCallback() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _disableCallback)[_disableCallback] !== null;
	  }
	  setDisableCallback(fn) {
	    if (main_core.Type.isFunction(fn)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _disableCallback)[_disableCallback] = fn;
	    }
	  }
	  invokeDisableCallback() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _disableCallback)[_disableCallback]();
	  }
	  getContainer() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _container)[_container] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _container)[_container] = main_core.Tag.render(_t || (_t = _`
				<button 
					type="button" 
					class="ui-text-editor-toolbar-button"
					onclick="${0}"
				>
				</button>
			`), babelHelpers.classPrivateFieldLooseBase(this, _handleClick)[_handleClick].bind(this));
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _container)[_container];
	  }
	  render() {
	    return this.getContainer();
	  }
	}
	function _handleClick2() {
	  this.emit('onClick');
	}

	function wrapTextInParagraph(text) {
	  let result = '';
	  const parts = text.split(/((?:\r?\n){2})/);
	  for (const part of parts) {
	    if (part === '\n\n' || part === '\r\n\r\n') {
	      continue;
	    }
	    result += `<p>${part.replaceAll(/(\r?\n)/g, '<br>')}</p>`;
	  }
	  return result;
	}

	/* eslint-disable no-underscore-dangle */
	class QuoteNode extends ui_lexical_core.ElementNode {
	  static getType() {
	    return 'quote';
	  }
	  static clone(node) {
	    return new QuoteNode(node.__key);
	  }
	  createDOM(config, editor) {
	    var _config$theme;
	    const element = document.createElement('blockquote');
	    element.setAttribute('spellcheck', 'false');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.quote)) {
	      main_core.Dom.addClass(element, config.theme.quote);
	    }
	    return element;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	  static importDOM() {
	    return {
	      blockquote: node => ({
	        conversion: element => {
	          return {
	            node: $createQuoteNode()
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  static importJSON(serializedNode) {
	    const node = $createQuoteNode();
	    node.setFormat(serializedNode.format);
	    node.setIndent(serializedNode.indent);
	    node.setDirection(serializedNode.direction);
	    return node;
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'quote'
	    };
	  }
	  canIndent() {
	    return false;
	  }
	  isInline() {
	    return false;
	  }
	  canReplaceWith(replacement) {
	    return false;
	  }
	  collapseAtStart(selection) {
	    // const paragraph = $createParagraphNode();
	    // const children = this.getChildren();
	    // children.forEach((child) => paragraph.append(child));
	    // this.replace(paragraph);
	    $removeQuote(this);
	    return true;
	  }
	  canBeEmpty() {
	    return false;
	  }
	  isShadowRoot() {
	    return true;
	  }

	  // insertNewAfter(selection: RangeSelection, restoreSelection = true): null | ParagraphNode
	  // {
	  // 	const children = this.getChildren();
	  // 	const childrenLength = children.length;
	  //
	  // 	if (
	  // 		childrenLength >= 2
	  // 		&& children[childrenLength - 1].getTextContent() === '\n'
	  // 		&& children[childrenLength - 2].getTextContent() === '\n'
	  // 		&& selection.isCollapsed()
	  // 		&& selection.anchor.key === this.__key
	  // 		&& selection.anchor.offset === childrenLength
	  // 	)
	  // 	{
	  // 		children[childrenLength - 1].remove();
	  // 		children[childrenLength - 2].remove();
	  // 		const newElement = $createParagraphNode();
	  // 		this.insertAfter(newElement, restoreSelection);
	  //
	  // 		return newElement;
	  // 	}
	  //
	  // 	selection.insertLineBreak();
	  //
	  // 	return null;
	  // }
	}

	function $createQuoteNode() {
	  return ui_lexical_core.$applyNodeReplacement(new QuoteNode());
	}
	function $isQuoteNode(node) {
	  return node instanceof QuoteNode;
	}
	function $removeQuote(quoteNode) {
	  if (!$isQuoteNode(quoteNode)) {
	    return false;
	  }
	  let lastElement = quoteNode;
	  for (const child of quoteNode.getChildren()) {
	    if (ui_lexical_core.$isElementNode(child) || ui_lexical_core.$isDecoratorNode(child)) {
	      lastElement = lastElement.insertAfter(child);
	    } else {
	      lastElement = lastElement.insertAfter(ui_lexical_core.$createParagraphNode().append(child));
	    }
	  }
	  quoteNode.remove();
	  return true;
	}

	function $getAncestor(node, predicate) {
	  let parent = node;
	  while (parent !== null && parent.getParent() !== null && !predicate(parent)) {
	    parent = parent.getParentOrThrow();
	  }
	  return predicate(parent) ? parent : null;
	}

	function $isBlockNode(node) {
	  return (ui_lexical_core.$isElementNode(node) || ui_lexical_core.$isDecoratorNode(node)) && !node.isInline() && !node.isParentRequired();
	}

	function $wrapNodes(selection, createElement) {
	  if (selection === null) {
	    return null;
	  }
	  const anchor = selection.anchor;
	  const anchorNode = anchor.getNode();
	  const element = createElement();
	  if (ui_lexical_core.$isRootOrShadowRoot(anchorNode)) {
	    const firstChild = anchorNode.getFirstChild();
	    if (firstChild) {
	      firstChild.replace(element, true);
	    } else {
	      anchorNode.append(element);
	    }
	    return element;
	  }
	  const handled = new Set();
	  const nodes = selection.getNodes();
	  const firstSelectedBlock = $getAncestor(selection.anchor.getNode(), $isBlockNode);
	  if (firstSelectedBlock && !nodes.includes(firstSelectedBlock)) {
	    nodes.unshift(firstSelectedBlock);
	  }
	  handled.add(element.getKey());
	  let firstNode = true;
	  for (const node of nodes) {
	    if (!$isBlockNode(node) || handled.has(node.getKey())) {
	      continue;
	    }
	    const isParentHandled = $getAncestor(node.getParent(), parentNode => handled.has(parentNode.getKey()));
	    if (isParentHandled) {
	      continue;
	    }
	    if (firstNode) {
	      firstNode = false;
	      node.replace(element);
	      element.append(node);
	    } else {
	      element.append(node);
	    }
	    handled.add(node.getKey());
	  }
	  return element;
	}

	/** @memberof BX.UI.TextEditor.Plugins.Quote */
	const INSERT_QUOTE_COMMAND = ui_lexical_core.createCommand('INSERT_QUOTE_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.Quote */
	const FORMAT_QUOTE_COMMAND = ui_lexical_core.createCommand('FORMAT_QUOTE_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.Quote */
	const REMOVE_QUOTE_COMMAND = ui_lexical_core.createCommand('REMOVE_QUOTE_COMMAND');
	var _registerCommands = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerComponents = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class QuotePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents, {
	      value: _registerComponents2
	    });
	    Object.defineProperty(this, _registerCommands, {
	      value: _registerCommands2
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands)[_registerCommands]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents)[_registerComponents]();
	  }
	  static getName() {
	    return 'Quote';
	  }
	  static getNodes(editor) {
	    return [QuoteNode];
	  }
	  importBBCode() {
	    return {
	      quote: () => ({
	        conversion: node => {
	          return {
	            node: $createQuoteNode(),
	            after: childLexicalNodes => {
	              return $normalizeTextNodes(childLexicalNodes);
	            }
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      quote: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'quote'
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: QuoteNode,
	        validate: quoteNode => {
	          let prevParagraph = null;
	          quoteNode.getChildren().forEach(child => {
	            if (shouldWrapInParagraph(child)) {
	              if (prevParagraph === null) {
	                const paragraph = ui_lexical_core.$createParagraphNode();
	                child.replace(paragraph);
	                paragraph.append(child);
	                prevParagraph = paragraph;
	              } else {
	                prevParagraph.append(child);
	              }
	            } else {
	              prevParagraph = null;
	            }
	          });
	          return false;
	        }
	      }],
	      bbcodeMap: {
	        quote: 'quote'
	      }
	    };
	  }
	}
	function _registerCommands2() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_QUOTE_COMMAND, payload => {
	    const quoteNode = $createQuoteNode();
	    if (main_core.Type.isPlainObject(payload) && main_core.Type.isStringFilled(payload.content)) {
	      const nodes = $importFromBBCode(payload.content, this.getEditor(), false);
	      quoteNode.append(...$normalizeTextNodes(nodes));
	      ui_lexical_utils.$insertNodeToNearestRoot(quoteNode);
	    } else {
	      quoteNode.append(ui_lexical_core.$createParagraphNode());
	      ui_lexical_utils.$insertNodeToNearestRoot(quoteNode);
	    }
	    quoteNode.selectStart();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(FORMAT_QUOTE_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      const quoteNode = $createQuoteNode();
	      $wrapNodes(selection, () => quoteNode);
	      if (quoteNode.isEmpty()) {
	        quoteNode.append(ui_lexical_core.$createParagraphNode());
	      }
	      quoteNode.selectStart();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(REMOVE_QUOTE_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    let quoteNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), $isQuoteNode);
	    if (!quoteNode) {
	      quoteNode = ui_lexical_utils.$findMatchingParent(selection.focus.getNode(), $isQuoteNode);
	    }
	    $removeQuote(quoteNode);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerComponents2() {
	  this.getEditor().getComponentRegistry().register('quote', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --quote"></span>');
	    button.setBlockType('quote');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_QUOTE'));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        if (button.isActive()) {
	          this.getEditor().dispatchCommand(REMOVE_QUOTE_COMMAND);
	        } else if (this.getEditor().getNewLineMode() === NewLineMode.LINE_BREAK) {
	          this.getEditor().dispatchCommand(INSERT_QUOTE_COMMAND);
	        } else {
	          this.getEditor().dispatchCommand(FORMAT_QUOTE_COMMAND);
	        }
	      });
	    });
	    return button;
	  });
	}



	var Quote = /*#__PURE__*/Object.freeze({
		QuoteNode: QuoteNode,
		$createQuoteNode: $createQuoteNode,
		$isQuoteNode: $isQuoteNode,
		$removeQuote: $removeQuote,
		INSERT_QUOTE_COMMAND: INSERT_QUOTE_COMMAND,
		FORMAT_QUOTE_COMMAND: FORMAT_QUOTE_COMMAND,
		REMOVE_QUOTE_COMMAND: REMOVE_QUOTE_COMMAND,
		QuotePlugin: QuotePlugin
	});

	/*
	eslint-disable no-underscore-dangle,
	@bitrix24/bitrix24-rules/no-pseudo-private,
	@bitrix24/bitrix24-rules/no-native-dom-methods
	*/
	function convertSpoilerContentElement(domNode) {
	  const node = $createSpoilerContentNode();
	  return {
	    node
	  };
	}
	class SpoilerContentNode extends ui_lexical_core.ElementNode {
	  static getType() {
	    return 'spoiler-content';
	  }
	  static clone(node) {
	    return new SpoilerContentNode(node.__key);
	  }
	  createDOM(config, editor) {
	    var _config$theme, _config$theme$spoiler;
	    const dom = document.createElement('div');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : (_config$theme$spoiler = _config$theme.spoiler) == null ? void 0 : _config$theme$spoiler.content)) {
	      main_core.Dom.addClass(dom, config.theme.spoiler.content);
	    }
	    return dom;
	  }
	  updateDOM(prevNode, dom, config) {
	    return false;
	  }
	  static importDOM() {
	    return {
	      div: domNode => {
	        if (!domNode.hasAttribute('data-spoiler-content')) {
	          return null;
	        }
	        return {
	          conversion: convertSpoilerContentElement,
	          priority: 2
	        };
	      }
	    };
	  }
	  static importJSON(serializedNode) {
	    return $createSpoilerContentNode();
	  }
	  exportDOM() {
	    const element = document.createElement('div');
	    element.setAttribute('data-spoiler-content', 'true');
	    return {
	      element
	    };
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'spoiler-content',
	      version: 1
	    };
	  }
	  isShadowRoot() {
	    return true;
	  }
	  isParentRequired() {
	    return true;
	  }
	  createParentElementNode() {
	    return $createSpoilerNode();
	  }
	  canIndent() {
	    return false;
	  }
	  canInsertAfter(node) {
	    return false;
	  }
	  canReplaceWith(replacement) {
	    return false;
	  }
	  insertBefore(node) {
	    const firstChild = this.getFirstChild();
	    const nodeToInsert = ui_lexical_core.$isElementNode(node) || ui_lexical_core.$isDecoratorNode(node) ? node : ui_lexical_core.$createParagraphNode().append(node);
	    if (firstChild === null) {
	      this.append(nodeToInsert);
	    } else {
	      firstChild.insertBefore(nodeToInsert);
	    }
	    return nodeToInsert;
	  }
	  insertAfter(node) {
	    const nodeToInsert = ui_lexical_core.$isElementNode(node) || ui_lexical_core.$isDecoratorNode(node) ? node : ui_lexical_core.$createParagraphNode().append(node);
	    this.append(nodeToInsert);
	    return nodeToInsert;
	  }
	}
	function $createSpoilerContentNode() {
	  return new SpoilerContentNode();
	}
	function $isSpoilerContentNode(node) {
	  return node instanceof SpoilerContentNode;
	}

	/* eslint-disable no-underscore-dangle */
	class SpoilerTitleTextNode extends ui_lexical_core.TextNode {
	  static getType() {
	    return 'spoiler-title-text';
	  }
	  static clone(node) {
	    return new SpoilerTitleTextNode(node.__text, node.__key);
	  }
	  createDOM(config) {
	    return super.createDOM(config);
	  }
	  static importJSON(serializedNode) {
	    return $createSpoilerTitleTextNode(serializedNode.text);
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'spoiler-title-text'
	    };
	  }
	}
	function $createSpoilerTitleTextNode(text = '') {
	  return ui_lexical_core.$applyNodeReplacement(new SpoilerTitleTextNode(text));
	}
	function $isSpoilerTitleTextNode(node) {
	  return node instanceof SpoilerTitleTextNode;
	}

	/* eslint-disable @bitrix24/bitrix24-rules/no-native-dom-methods */
	const INSERT_SPOILER_COMMAND = ui_lexical_core.createCommand('INSERT_SPOILER_COMMAND');
	const REMOVE_SPOILER_COMMAND = ui_lexical_core.createCommand('REMOVE_SPOILER_COMMAND');
	var _registerComponents$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _registerCommands$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerNodeTransforms = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerNodeTransforms");
	var _handleDeleteCharacter = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDeleteCharacter");
	var _handleEnter = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEnter");
	var _handlePaste = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handlePaste");
	class SpoilerPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _handlePaste, {
	      value: _handlePaste2
	    });
	    Object.defineProperty(this, _handleEnter, {
	      value: _handleEnter2
	    });
	    Object.defineProperty(this, _handleDeleteCharacter, {
	      value: _handleDeleteCharacter2
	    });
	    Object.defineProperty(this, _registerNodeTransforms, {
	      value: _registerNodeTransforms2
	    });
	    Object.defineProperty(this, _registerCommands$1, {
	      value: _registerCommands2$1
	    });
	    Object.defineProperty(this, _registerComponents$1, {
	      value: _registerComponents2$1
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerNodeTransforms)[_registerNodeTransforms]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$1)[_registerCommands$1]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$1)[_registerComponents$1]();
	  }
	  static getName() {
	    return 'Spoiler';
	  }
	  static getNodes(editor) {
	    return [SpoilerNode, SpoilerTitleNode, SpoilerContentNode, SpoilerTitleTextNode];
	  }
	  importBBCode() {
	    return {
	      spoiler: () => ({
	        conversion: node => {
	          const title = main_core.Type.isStringFilled(node.getValue()) ? trimSpoilerTitle(node.getValue()) : main_core.Loc.getMessage('TEXT_EDITOR_SPOILER_TITLE');
	          return {
	            node: $createSpoilerNode(false),
	            after: childLexicalNodes => {
	              return [$createSpoilerTitleNode().append($createSpoilerTitleTextNode(title)), $createSpoilerContentNode().append(...$normalizeTextNodes(childLexicalNodes))];
	            }
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      spoiler: spoilerNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        const titleNode = spoilerNode.getChildren()[0];
	        const title = trimSpoilerTitle(titleNode.getTextContent());
	        const value = title === main_core.Loc.getMessage('TEXT_EDITOR_SPOILER_TITLE') ? '' : title;
	        return {
	          node: scheme.createElement({
	            name: 'spoiler',
	            value
	          })
	        };
	      },
	      'spoiler-title': node => {
	        return {
	          node: null
	        };
	      },
	      'spoiler-content': node => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createFragment()
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: SpoilerNode
	      }, {
	        nodeClass: SpoilerContentNode,
	        validate: contentNode => {
	          contentNode.getChildren().forEach(child => {
	            if (shouldWrapInParagraph(child)) {
	              const paragraph = ui_lexical_core.$createParagraphNode();
	              child.replace(paragraph);
	              paragraph.append(child);
	            }
	          });
	          return false;
	        }
	      }],
	      bbcodeMap: {
	        spoiler: 'spoiler',
	        'spoiler-content': 'spoiler'
	      }
	    };
	  }
	}
	function _registerComponents2$1() {
	  this.getEditor().getComponentRegistry().register('spoiler', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --insert-spoiler"></span>');
	    button.setBlockType('spoiler');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_SPOILER'));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        if (button.isActive()) {
	          this.getEditor().dispatchCommand(REMOVE_SPOILER_COMMAND);
	        } else {
	          this.getEditor().dispatchCommand(INSERT_SPOILER_COMMAND);
	        }
	      });
	    });
	    return button;
	  });
	}
	function _registerCommands2$1() {
	  this.cleanUpRegister(
	  // This handles the case when container is collapsed and we delete its previous sibling
	  // into it, it would cause collapsed content deleted (since it's display: none, and selection
	  // swallows it when deletes single char). Instead we expand container, which is although
	  // not perfect, but avoids bigger problem
	  this.getEditor().registerCommand(ui_lexical_core.DELETE_CHARACTER_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleDeleteCharacter)[_handleDeleteCharacter].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ENTER_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleEnter)[_handleEnter].bind(this), ui_lexical_core.COMMAND_PRIORITY_NORMAL), this.getEditor().registerCommand(ui_lexical_core.INSERT_PARAGRAPH_COMMAND, event => {
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      const spoilerTitleNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => $isSpoilerTitleNode(node));
	      if (spoilerTitleNode) {
	        const newBlock = spoilerTitleNode.insertNewAfter(selection);
	        if (newBlock) {
	          newBlock.selectStart();
	        }
	        return true;
	      }
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.PASTE_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handlePaste)[_handlePaste].bind(this), ui_lexical_core.COMMAND_PRIORITY_NORMAL), this.getEditor().registerCommand(INSERT_SPOILER_COMMAND, payload => {
	    this.getEditor().update(() => {
	      const title = main_core.Type.isPlainObject(payload) && main_core.Type.isStringFilled(payload.title) ? payload.title : undefined;
	      const selection = ui_lexical_core.$getSelection();
	      const spoiler = insertSpoiler(selection, title);
	      spoiler.getTitleNode().select();
	    });
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(REMOVE_SPOILER_COMMAND, () => {
	    this.getEditor().update(() => {
	      const selection = ui_lexical_core.$getSelection();
	      if (!ui_lexical_core.$isRangeSelection(selection)) {
	        return;
	      }
	      let spoilerNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), $isSpoilerNode);
	      if (!spoilerNode) {
	        spoilerNode = ui_lexical_utils.$findMatchingParent(selection.focus.getNode(), $isSpoilerNode);
	      }
	      $removeSpoiler(spoilerNode);
	    });
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerNodeTransforms2() {
	  this.cleanUpRegister(
	  // Structure enforcing transformers for each node type. In case nesting structure is not
	  // "Container > Title + Content" it'll unwrap nodes and convert it back
	  // to regular content.
	  this.getEditor().registerNodeTransform(SpoilerNode, node => {
	    const children = node.getChildren();
	    if (children.length !== 2 || !$isSpoilerTitleNode(children[0]) || !$isSpoilerContentNode(children[1])) {
	      for (const child of children) {
	        if (ui_lexical_core.$isElementNode(child) || ui_lexical_core.$isDecoratorNode(child)) {
	          node.insertBefore(child);
	        } else {
	          node.insertBefore(ui_lexical_core.$createParagraphNode().append(child));
	        }
	      }
	      node.remove();
	    }
	  }), this.getEditor().registerNodeTransform(SpoilerTitleNode, node => {
	    const parent = node.getParent();
	    if (!$isSpoilerNode(parent)) {
	      node.replace(ui_lexical_core.$createParagraphNode().append(...node.getChildren()));
	    } else if (node.getChildrenSize() === 1 && !$isSpoilerTitleTextNode(node.getFirstChild()) || node.getChildrenSize() > 1) {
	      ui_lexical_core.$setSelection(null);
	      const textContent = trimSpoilerTitle(node.getTextContent());
	      node.clear();
	      node.append($createSpoilerTitleTextNode(textContent));
	      node.select();
	    }
	  }), this.getEditor().registerNodeTransform(SpoilerTitleTextNode, node => {
	    const parent = node.getParent();
	    if (!$isSpoilerTitleNode(parent)) {
	      node.replace(ui_lexical_core.$createParagraphNode().append(ui_lexical_core.$createTextNode(node.getTextContent())));
	    }
	  }), this.getEditor().registerNodeTransform(SpoilerContentNode, node => {
	    const parent = node.getParent();
	    if (!$isSpoilerNode(parent)) {
	      const children = node.getChildren();
	      for (const child of children) {
	        if (ui_lexical_core.$isElementNode(child) || ui_lexical_core.$isDecoratorNode(child)) {
	          node.insertBefore(child);
	        } else {
	          node.insertBefore(ui_lexical_core.$createParagraphNode().append(child));
	        }
	      }
	      node.remove();
	    }
	  }));
	}
	function _handleDeleteCharacter2() {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || !selection.isCollapsed() || selection.anchor.offset !== 0) {
	    return false;
	  }
	  const anchorNode = selection.anchor.getNode();
	  const topLevelElement = anchorNode.getTopLevelElement();
	  if (topLevelElement === null) {
	    return false;
	  }
	  const container = topLevelElement.getPreviousSibling();
	  if (!$isSpoilerNode(container) || container.getOpen()) {
	    return false;
	  }
	  container.setOpen(true);
	  return true;
	}
	function _handleEnter2(event) {
	  if (event && (event.ctrlKey || event.metaKey)) {
	    // Handling CMD+Enter to toggle spoiler element collapsed state
	    const selection = ui_lexical_core.$getPreviousSelection();
	    if (ui_lexical_core.$isRangeSelection(selection) && selection.isCollapsed()) {
	      const parent = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => ui_lexical_core.$isElementNode(node) && !node.isInline());
	      if ($isSpoilerTitleNode(parent)) {
	        const container = parent.getParent();
	        if ($isSpoilerNode(container)) {
	          container.toggleOpen();
	          ui_lexical_core.$setSelection(selection.clone());
	          return true;
	        }
	      }
	    }
	  }
	  return false;
	}
	function _handlePaste2(event) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || !(event instanceof ClipboardEvent) || event.clipboardData === null) {
	    return false;
	  }
	  const spoilerTitleNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => $isSpoilerTitleNode(node));
	  if (spoilerTitleNode) {
	    ui_lexical_clipboard.$insertDataTransferForPlainText(event.clipboardData, selection);
	    return true;
	  }
	  return false;
	}
	function insertSpoiler(selection, title) {
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return null;
	  }
	  const anchor = selection.anchor;
	  const anchorNode = anchor.getNode();
	  const spoiler = $createSpoiler(true, title);
	  if (ui_lexical_core.$isRootOrShadowRoot(anchorNode)) {
	    const firstChild = anchorNode.getFirstChild();
	    if (firstChild) {
	      firstChild.replace(spoiler, true);
	    } else {
	      anchorNode.append(spoiler);
	    }
	    return spoiler;
	  }
	  const handled = new Set();
	  const nodes = selection.getNodes();
	  const firstSelectedBlock = $getAncestor(selection.anchor.getNode(), $isBlockNode);
	  if (firstSelectedBlock && !nodes.includes(firstSelectedBlock)) {
	    nodes.unshift(firstSelectedBlock);
	  }
	  handled.add(spoiler.getKey());
	  handled.add(spoiler.getTitleNode().getKey());
	  handled.add(spoiler.getContentNode().getKey());
	  let firstNode = true;
	  for (const node of nodes) {
	    if (!$isBlockNode(node) || handled.has(node.getKey())) {
	      continue;
	    }
	    const isParentHandled = $getAncestor(node.getParent(), parentNode => handled.has(parentNode.getKey()));
	    if (isParentHandled) {
	      continue;
	    }
	    if (firstNode) {
	      firstNode = false;
	      node.replace(spoiler);
	      spoiler.getContentNode().append(node);
	    } else {
	      spoiler.getContentNode().append(node);
	    }

	    // let parent: ElementNode = node.getParent();
	    // while (parent !== null)
	    // {
	    // 	const parentKey = parent.getKey();
	    // 	const nextParent: ElementNode = parent.getParent();
	    // 	if ($isRootOrShadowRoot(nextParent) && !handled.has(parentKey))
	    // 	{
	    // 		handled.add(parentKey);
	    // 		createSpoilerOrMerge(parent);
	    //
	    // 		break;
	    // 	}
	    //
	    // 	parent = nextParent;
	    // }

	    handled.add(node.getKey());
	  }
	  return spoiler;
	}
	function trimSpoilerTitle(title) {
	  return title.trim().replaceAll(/\r?\n|\t/gm, '').replace('\r', '').replaceAll(/\s+/g, ' ');
	}

	/*
	eslint-disable no-underscore-dangle,
	@bitrix24/bitrix24-rules/no-pseudo-private,
	@bitrix24/bitrix24-rules/no-native-dom-methods
	*/
	function convertSummaryElement(domNode) {
	  const node = $createSpoilerTitleNode();
	  return {
	    node
	  };
	}
	class SpoilerTitleNode extends ui_lexical_core.ElementNode {
	  constructor(...args) {
	    super(...args);
	    this.__language = 'hack';
	    this.__flags = UNFORMATTED;
	  }
	  static getType() {
	    return 'spoiler-title';
	  }
	  static clone(node) {
	    return new SpoilerTitleNode(node.__key);
	  }
	  createDOM(config, editor) {
	    var _config$theme, _config$theme$spoiler;
	    const dom = document.createElement('summary');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : (_config$theme$spoiler = _config$theme.spoiler) == null ? void 0 : _config$theme$spoiler.title)) {
	      main_core.Dom.addClass(dom, config.theme.spoiler.title);
	    }
	    main_core.Dom.addClass(dom, 'ui-icon-set__scope');
	    return dom;
	  }
	  updateDOM(prevNode, dom, config) {
	    return false;
	  }
	  static importDOM() {
	    return {
	      summary: domNode => {
	        return {
	          conversion: convertSummaryElement,
	          priority: 1
	        };
	      }
	    };
	  }
	  static importJSON(serializedNode) {
	    return $createSpoilerTitleNode();
	  }
	  exportDOM() {
	    const element = document.createElement('summary');
	    return {
	      element
	    };
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'spoiler-title',
	      version: 1
	    };
	  }
	  collapseAtStart(selection) {
	    const spoilerNode = this.getParent();
	    if (!$isSpoilerNode(spoilerNode)) {
	      return false;
	    }
	    return $removeSpoiler(spoilerNode);
	  }
	  insertNewAfter(selection, restoreSelection = true) {
	    const containerNode = this.getParentOrThrow();
	    if (!$isSpoilerNode(containerNode)) {
	      throw new Error('SpoilerTitleNode expects to be child of SpoilerNode');
	    }
	    if (containerNode.getOpen()) {
	      const contentNode = this.getNextSibling();
	      if (!$isSpoilerContentNode(contentNode)) {
	        throw new Error('SpoilerTitleNode expects to have SpoilerContentNode sibling');
	      }
	      const firstChild = contentNode.getFirstChild();
	      if (ui_lexical_core.$isElementNode(firstChild) || ui_lexical_core.$isDecoratorNode(firstChild)) {
	        return firstChild;
	      }
	      const paragraph = ui_lexical_core.$createParagraphNode();
	      contentNode.append(paragraph);
	      return paragraph;
	    }
	    const paragraph = ui_lexical_core.$createParagraphNode();
	    containerNode.insertAfter(paragraph, restoreSelection);
	    return paragraph;
	  }
	  isParentRequired() {
	    return true;
	  }
	  createParentElementNode() {
	    return $createSpoilerNode();
	  }
	  canIndent() {
	    return false;
	  }
	  insertAfter(nodeToInsert) {
	    const textContent = nodeToInsert.getTextContent();
	    this.clear();
	    this.append($createSpoilerTitleTextNode(trimSpoilerTitle(textContent)));
	    return this;
	  }
	}
	function $createSpoilerTitleNode() {
	  return new SpoilerTitleNode();
	}
	function $isSpoilerTitleNode(node) {
	  return node instanceof SpoilerTitleNode;
	}
	function $removeSpoiler(spoilerNode) {
	  if (!$isSpoilerNode(spoilerNode)) {
	    return false;
	  }
	  const contentNode = spoilerNode.getContentNode();
	  let lastElement = spoilerNode;
	  if (contentNode !== null) {
	    for (const child of contentNode.getChildren()) {
	      if (ui_lexical_core.$isElementNode(child) || ui_lexical_core.$isDecoratorNode(child)) {
	        lastElement = lastElement.insertAfter(child);
	      } else {
	        lastElement = lastElement.insertAfter(ui_lexical_core.$createParagraphNode().append(child));
	      }
	    }
	  }
	  spoilerNode.remove();
	  return true;
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class SpoilerNode extends ui_lexical_core.ElementNode {
	  constructor(open, key) {
	    super(key);
	    this.__open = open;
	  }
	  static getType() {
	    return 'spoiler';
	  }
	  static clone(node) {
	    return new SpoilerNode(node.__open, node.__key);
	  }
	  createDOM(config, editor) {
	    var _config$theme, _config$theme$spoiler;
	    const details = document.createElement('details');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : (_config$theme$spoiler = _config$theme.spoiler) == null ? void 0 : _config$theme$spoiler.container)) {
	      main_core.Dom.addClass(details, config.theme.spoiler.container);
	    }
	    details.open = this.__open;
	    main_core.Event.bind(details, 'toggle', () => {
	      const open = editor.getEditorState().read(() => this.getOpen());
	      if (open !== details.open) {
	        editor.update(() => this.toggleOpen());
	      }
	    });
	    return details;
	  }
	  updateDOM(prevNode, dom, config) {
	    if (prevNode.__open !== this.__open) {
	      dom.open = this.__open;
	    }
	    return false;
	  }
	  static importDOM() {
	    return {
	      details: domNode => {
	        return {
	          conversion: details => {
	            const isOpen = main_core.Type.isBoolean(details.open) ? details.open : true;
	            return {
	              node: $createSpoiler(isOpen)
	            };
	          },
	          priority: 1
	        };
	      }
	    };
	  }
	  static importJSON(serializedNode) {
	    return $createSpoilerNode(serializedNode.open);
	  }
	  exportDOM(editor) {
	    const details = document.createElement('details');
	    if (this.__open) {
	      details.setAttribute('open', true);
	    }
	    return {
	      element: details
	    };
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      open: this.__open,
	      type: 'spoiler',
	      version: 1
	    };
	  }
	  isShadowRoot() {
	    return true;
	  }
	  canBeEmpty() {
	    return false;
	  }
	  append(...nodesToAppend) {
	    for (const node of nodesToAppend) {
	      if ($isSpoilerTitleNode(node)) {
	        const titleNode = node;
	        if (this.getTitleNode() === null) {
	          super.append(titleNode);
	        } else {
	          this.getTitleNode().clear();
	          this.getTitleNode().append($createSpoilerTitleTextNode(node.getTextContent()));
	        }
	      } else if ($isSpoilerContentNode(node)) {
	        const contentNode = node;
	        if (this.getContentNode() === null) {
	          super.append(contentNode);
	        } else {
	          this.getContentNode().append(...contentNode.getChildren());
	        }
	      } else if (ui_lexical_core.$isElementNode(node) || ui_lexical_core.$isDecoratorNode(node)) {
	        this.getContentNode().append(node);
	      } else {
	        this.getContentNode().append(ui_lexical_core.$createParagraphNode().append(node));
	      }
	    }
	    return this;
	  }
	  getTitleNode() {
	    return this.getChildren()[0] || null;
	  }
	  getContentNode() {
	    return this.getChildren()[1] || null;
	  }
	  setOpen(open) {
	    const writable = this.getWritable();
	    writable.__open = open;
	  }
	  getOpen() {
	    return this.getLatest().__open;
	  }
	  toggleOpen() {
	    this.setOpen(!this.getOpen());
	  }
	}
	function $createSpoiler(isOpen, title = main_core.Loc.getMessage('TEXT_EDITOR_SPOILER_TITLE')) {
	  return $createSpoilerNode(isOpen).append($createSpoilerTitleNode().append($createSpoilerTitleTextNode(title)), $createSpoilerContentNode());
	}
	function $createSpoilerNode(isOpen) {
	  return new SpoilerNode(isOpen);
	}
	function $isSpoilerNode(node) {
	  return node instanceof SpoilerNode;
	}



	var Spoiler = /*#__PURE__*/Object.freeze({
		SpoilerNode: SpoilerNode,
		$createSpoiler: $createSpoiler,
		$createSpoilerNode: $createSpoilerNode,
		$isSpoilerNode: $isSpoilerNode,
		convertSummaryElement: convertSummaryElement,
		SpoilerTitleNode: SpoilerTitleNode,
		$createSpoilerTitleNode: $createSpoilerTitleNode,
		$isSpoilerTitleNode: $isSpoilerTitleNode,
		$removeSpoiler: $removeSpoiler,
		convertSpoilerContentElement: convertSpoilerContentElement,
		SpoilerContentNode: SpoilerContentNode,
		$createSpoilerContentNode: $createSpoilerContentNode,
		$isSpoilerContentNode: $isSpoilerContentNode,
		INSERT_SPOILER_COMMAND: INSERT_SPOILER_COMMAND,
		REMOVE_SPOILER_COMMAND: REMOVE_SPOILER_COMMAND,
		SpoilerPlugin: SpoilerPlugin,
		insertSpoiler: insertSpoiler,
		trimSpoilerTitle: trimSpoilerTitle
	});

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class CustomParagraphNode extends ui_lexical_core.ParagraphNode {
	  constructor(__mode, key) {
	    super(key);
	    this.__mode = NewLineMode.MIXED;
	    this.__mode = __mode;
	  }
	  static getType() {
	    return 'custom-paragraph';
	  }
	  static clone(node) {
	    return new CustomParagraphNode(node.__mode, node.__key);
	  }
	  insertNewAfter(selection, restoreSelection) {
	    if (this.__mode === NewLineMode.PARAGRAPH) {
	      return super.insertNewAfter(selection, restoreSelection);
	    }
	    if (this.__mode === NewLineMode.MIXED) {
	      const children = this.getChildren();
	      const childrenLength = children.length;
	      if (childrenLength >= 1 && children[childrenLength - 1].getTextContent() === '\n' && selection.isCollapsed() && selection.anchor.key === this.__key && selection.anchor.offset === childrenLength) {
	        children[childrenLength - 1].remove();
	        const newElement = ui_lexical_core.$createParagraphNode();
	        this.insertAfter(newElement, restoreSelection);
	        return newElement;
	      }
	      if (ui_lexical_core.$hasUpdateTag('paste')) {
	        return super.insertNewAfter(selection, restoreSelection);
	      }
	    }
	    selection.insertLineBreak();
	    return null;
	  }

	  // createDOM(config) {
	  // 	const dom = super.createDOM(config);
	  // 	dom.style = "border: 1px dashed tomato";
	  //
	  // 	return dom;
	  // }

	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      mode: this.__mode,
	      type: 'custom-paragraph',
	      version: 1
	    };
	  }
	  static importDOM() {
	    return {
	      p: node => ({
	        conversion: element => {
	          return {
	            node: ui_lexical_core.$createParagraphNode()
	          };
	        },
	        priority: 1
	      }),
	      h1: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      }),
	      h2: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      }),
	      h3: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      }),
	      h4: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      }),
	      h5: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      }),
	      h6: node => ({
	        conversion: convertHeadingElement,
	        priority: 1
	      })
	    };
	  }
	  collapseAtStart() {
	    const children = this.getChildren();
	    // If we have an empty (trimmed) first paragraph and try and remove it,
	    // delete the paragraph as long as we have another sibling to go to
	    if (children.length === 0 || ui_lexical_core.$isTextNode(children[0]) && children[0].getTextContent().trim() === '') {
	      const nextSibling = this.getNextSibling();
	      if (nextSibling !== null) {
	        this.selectNext();
	        this.remove();
	        return true;
	      }
	      const prevSibling = this.getPreviousSibling();
	      if (prevSibling !== null) {
	        this.selectPrevious();
	        this.remove();
	        return true;
	      }
	      const parentNode = this.getParent();
	      if (parentNode !== null && !ui_lexical_core.$isRootNode(parentNode) && Object.getPrototypeOf(parentNode).hasOwnProperty('collapseAtStart')) {
	        return parentNode.collapseAtStart();
	      }
	    }
	    return false;
	  }
	  static importJSON(serializedParagraphNode) {
	    return super.importJSON(serializedParagraphNode);
	  }
	}
	function convertHeadingElement(element) {
	  return {
	    node: ui_lexical_core.$createParagraphNode(),
	    forChild: lexicalNode => {
	      if (ui_lexical_core.$isTextNode(lexicalNode)) {
	        lexicalNode.toggleFormat('bold');
	      }
	      return lexicalNode;
	    }
	  };
	}

	/** @memberof BX.UI.TextEditor.Plugins.Paragraph */
	const FORMAT_PARAGRAPH_COMMAND = ui_lexical_core.createCommand('FORMAT_PARAGRAPH_COMMAND');
	var _registerCommands$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerListeners = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _isBlockNode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("isBlockNode");
	var _handlePaste$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handlePaste");
	var _handleEscapeUp = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEscapeUp");
	var _handleEscapeDown = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEscapeDown");
	class ParagraphPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _handleEscapeDown, {
	      value: _handleEscapeDown2
	    });
	    Object.defineProperty(this, _handleEscapeUp, {
	      value: _handleEscapeUp2
	    });
	    Object.defineProperty(this, _handlePaste$1, {
	      value: _handlePaste2$1
	    });
	    Object.defineProperty(this, _isBlockNode, {
	      value: _isBlockNode2
	    });
	    Object.defineProperty(this, _registerListeners, {
	      value: _registerListeners2
	    });
	    Object.defineProperty(this, _registerCommands$2, {
	      value: _registerCommands2$2
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$2)[_registerCommands$2]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners)[_registerListeners]();
	  }
	  static getName() {
	    return 'Paragraph';
	  }
	  static getNodes(editor) {
	    return [CustomParagraphNode, {
	      replace: ui_lexical_core.ParagraphNode,
	      with: node => {
	        return new CustomParagraphNode(editor.getNewLineMode());
	      },
	      withClass: CustomParagraphNode
	    }];
	  }
	  importBBCode() {
	    return {
	      p: () => ({
	        conversion: node => convertParagraphNode(node),
	        priority: 0
	      }),
	      left: () => ({
	        conversion: node => convertParagraphNode(node),
	        priority: 0
	      }),
	      right: () => ({
	        conversion: node => convertParagraphNode(node),
	        priority: 0
	      }),
	      center: () => ({
	        conversion: node => convertParagraphNode(node),
	        priority: 0
	      }),
	      justify: () => ({
	        conversion: node => convertParagraphNode(node),
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      paragraph: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'p'
	          })
	        };
	      },
	      'custom-paragraph': lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'p'
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: CustomParagraphNode
	      }],
	      bbcodeMap: {
	        root: '#root',
	        tab: '#tab',
	        text: '#text',
	        paragraph: 'p',
	        'custom-paragraph': 'p',
	        linebreak: '#linebreak'
	      }
	    };
	  }
	}
	function _registerCommands2$2() {
	  this.cleanUpRegister(this.getEditor().registerCommand(FORMAT_PARAGRAPH_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      ui_lexical_selection.$setBlocksType(selection, () => ui_lexical_core.$createParagraphNode());
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR));
	}
	function _registerListeners2() {
	  this.cleanUpRegister(this.getEditor().registerNodeTransform(ui_lexical_core.RootNode, root => {
	    const lastChild = root.getLastChild();
	    if (!ui_lexical_core.$isParagraphNode(lastChild)) {
	      root.append(ui_lexical_core.$createParagraphNode());
	    }
	  }),
	  // When a block node is the first child pressing up/left arrow will insert paragraph
	  // above it to allow adding more content. It's similar what $insertBlockNode
	  // (mainly for decorators), except it'll always be possible to continue adding
	  // new content even if leading paragraph is accidentally deleted
	  this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_UP_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleEscapeUp)[_handleEscapeUp].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_LEFT_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleEscapeUp)[_handleEscapeUp].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW),
	  // When a block node is the last child pressing down/right arrow will insert paragraph
	  // below it to allow adding more content. It's similar what $insertBlockNode
	  // (mainly for decorators), except it'll always be possible to continue adding
	  // new content even if trailing paragraph is accidentally deleted
	  this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_DOWN_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleEscapeDown)[_handleEscapeDown].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_RIGHT_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleEscapeDown)[_handleEscapeDown].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.PASTE_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handlePaste$1)[_handlePaste$1].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _isBlockNode2(node) {
	  return $isQuoteNode(node) || $isCodeNode(node) || $isSpoilerNode(node);
	}
	function _handlePaste2$1(event) {
	  if (this.getEditor().getNewLineMode() === NewLineMode.PARAGRAPH) {
	    // use a build-in algorithm (Rich Text Plugin)
	    return false;
	  }
	  if (this.getEditor().getNewLineMode() === NewLineMode.LINE_BREAK) {
	    event.preventDefault();
	    this.getEditor().update(() => {
	      const selection = ui_lexical_core.$getSelection();
	      const {
	        clipboardData
	      } = event;
	      if (clipboardData !== null && ui_lexical_core.$isRangeSelection(selection)) {
	        ui_lexical_clipboard.$insertDataTransferForPlainText(clipboardData, selection);
	      }
	    }, {
	      tag: 'paste'
	    });
	    return true;
	  }

	  // Mixed Mode
	  const clipboardData = event.clipboardData;
	  if (!clipboardData || clipboardData.items.length !== 1 || clipboardData.items[0].type !== 'text/plain' && clipboardData.items[0].type !== 'text/uri-list') {
	    return false;
	  }
	  const text = clipboardData.getData('text/plain') || clipboardData.getData('text/uri-list');
	  const hasLineBreaks = /\n/.test(text);
	  if (!hasLineBreaks) {
	    return false;
	  }
	  event.preventDefault();
	  event.stopPropagation();
	  const html = wrapTextInParagraph(text);
	  const dataTransfer = new DataTransfer();
	  dataTransfer.setData('text/plain', clipboardData.getData('text/plain'));
	  dataTransfer.setData('text/html', html);
	  const pasteEvent = new ClipboardEvent('paste', {
	    clipboardData: dataTransfer,
	    bubbles: true,
	    cancelable: true
	  });
	  if (pasteEvent.clipboardData.items.length === 0) {
	    // Firefox
	    pasteEvent.clipboardData.setData('text/plain', clipboardData.getData('text/plain'));
	    pasteEvent.clipboardData.setData('text/html', html);
	  }
	  this.getEditor().getEditableContainer().dispatchEvent(pasteEvent);
	  return true;
	}
	function _handleEscapeUp2() {
	  const selection = ui_lexical_core.$getSelection();
	  if (ui_lexical_core.$isRangeSelection(selection) && selection.isCollapsed() && selection.anchor.offset === 0) {
	    const container = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), babelHelpers.classPrivateFieldLooseBase(this, _isBlockNode)[_isBlockNode]);
	    if (babelHelpers.classPrivateFieldLooseBase(this, _isBlockNode)[_isBlockNode](container)) {
	      var _container$getFirstDe;
	      const parent = container.getParent();
	      if (parent !== null && parent.getFirstChild() === container && (selection.anchor.key === ((_container$getFirstDe = container.getFirstDescendant()) == null ? void 0 : _container$getFirstDe.getKey()) || selection.anchor.key === container.getKey())) {
	        container.insertBefore(ui_lexical_core.$createParagraphNode());
	      }
	    }
	  }
	  return false;
	}
	function _handleEscapeDown2() {
	  const selection = ui_lexical_core.$getSelection();
	  if (ui_lexical_core.$isRangeSelection(selection) && selection.isCollapsed()) {
	    const container = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), babelHelpers.classPrivateFieldLooseBase(this, _isBlockNode)[_isBlockNode]);
	    if (babelHelpers.classPrivateFieldLooseBase(this, _isBlockNode)[_isBlockNode](container)) {
	      const parent = container.getParent();
	      if (parent !== null && parent.getLastChild() === container) {
	        const firstDescendant = container.getFirstDescendant();
	        const lastDescendant = container.getLastDescendant();
	        if (lastDescendant !== null && selection.anchor.key === lastDescendant.getKey() && selection.anchor.offset === lastDescendant.getTextContentSize() || firstDescendant !== null && selection.anchor.key === firstDescendant.getKey() && selection.anchor.offset === firstDescendant.getTextContentSize() || selection.anchor.key === container.getKey() && selection.anchor.offset === container.getTextContentSize()) {
	          container.insertAfter(ui_lexical_core.$createParagraphNode());
	        }
	      }
	    }
	  }
	  return false;
	}
	function convertParagraphNode(bbcodeNode) {
	  return {
	    node: ui_lexical_core.$createParagraphNode()
	    // after: (childLexicalNodes: Array<LexicalNode>): Array<LexicalNode> => {
	    // 	return trimLineBreaks(childLexicalNodes);
	    // },
	  };
	}



	var Paragraph = /*#__PURE__*/Object.freeze({
		FORMAT_PARAGRAPH_COMMAND: FORMAT_PARAGRAPH_COMMAND,
		ParagraphPlugin: ParagraphPlugin
	});

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class CodeTokenNode extends ui_lexical_core.TextNode {
	  /** @internal */

	  constructor(text, highlightType, key) {
	    super(text, key);
	    this.__flags = UNFORMATTED;
	    this.__highlightType = highlightType;
	  }
	  static getType() {
	    return 'code-token';
	  }
	  static clone(node) {
	    return new CodeTokenNode(node.__text, node.__highlightType || undefined, node.__key);
	  }
	  getHighlightType() {
	    const self = this.getLatest();
	    return self.__highlightType;
	  }
	  createDOM(config) {
	    const element = super.createDOM(config);
	    const className = getHighlightThemeClass(config.theme, this.__highlightType);
	    ui_lexical_utils.addClassNamesToElement(element, className);
	    return element;
	  }
	  updateDOM(prevNode, dom, config) {
	    const update = super.updateDOM(prevNode, dom, config);
	    const prevClassName = getHighlightThemeClass(config.theme, prevNode.__highlightType);
	    const nextClassName = getHighlightThemeClass(config.theme, this.__highlightType);
	    if (prevClassName !== nextClassName) {
	      if (prevClassName) {
	        ui_lexical_utils.removeClassNamesFromElement(dom, prevClassName);
	      }
	      if (nextClassName) {
	        ui_lexical_utils.addClassNamesToElement(dom, nextClassName);
	      }
	    }
	    return update;
	  }
	  static importJSON(serializedNode) {
	    const node = $createCodeTokenNode(serializedNode.text, serializedNode.highlightType);
	    node.setFormat(serializedNode.format);
	    node.setDetail(serializedNode.detail);
	    node.setMode(serializedNode.mode);
	    node.setStyle(serializedNode.style);
	    return node;
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      highlightType: this.getHighlightType(),
	      type: 'code-token',
	      version: 1
	    };
	  }

	  // Prevent formatting (bold, underline, etc)
	  setFormat(format) {
	    return this;
	  }
	  isParentRequired() {
	    return true;
	  }
	  createParentElementNode() {
	    return $createCodeNode();
	  }
	}
	function getHighlightThemeClass(theme, highlightType) {
	  return highlightType && theme && theme.codeHighlight && theme.codeHighlight[highlightType];
	}
	function $createCodeTokenNode(text, highlightType) {
	  return ui_lexical_core.$applyNodeReplacement(new CodeTokenNode(text, highlightType));
	}
	function $isCodeTokenNode(node) {
	  return node instanceof CodeTokenNode;
	}

	/* eslint-disable no-underscore-dangle */
	class CodeNode extends ui_lexical_core.ElementNode {
	  constructor(...args) {
	    super(...args);
	    this.__language = 'lexical-hack';
	    this.__flags = UNFORMATTED;
	  }
	  static getType() {
	    return 'code';
	  }
	  static clone(node) {
	    return new CodeNode(node.__key);
	  }
	  createDOM(config, editor) {
	    var _config$theme;
	    const element = document.createElement('code');
	    element.setAttribute('spellcheck', 'false');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.code)) {
	      main_core.Dom.addClass(element, config.theme.code);
	    }
	    return element;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	  exportDOM(editor) {
	    var _editor$_config, _editor$_config$theme;
	    const element = document.createElement('pre');
	    element.setAttribute('spellcheck', 'false');
	    if (main_core.Type.isStringFilled((_editor$_config = editor._config) == null ? void 0 : (_editor$_config$theme = _editor$_config.theme) == null ? void 0 : _editor$_config$theme.code)) {
	      main_core.Dom.addClass(element, editor._config.theme.code);
	    }
	    return {
	      element
	    };
	  }
	  static importDOM() {
	    return {
	      // Typically <pre> is used for code blocks, and <code> for inline code styles
	      // but if it's a multi line <code> we'll create a block. Pass through to
	      // inline format handled by TextNode otherwise.
	      code: node => {
	        const isMultiLine = node.textContent !== null && (/\r?\n/.test(node.textContent) || hasChildDOMNodeTag(node, 'BR'));
	        return isMultiLine ? {
	          conversion: convertPreElement,
	          priority: 1
	        } : null;
	      },
	      div: node => ({
	        conversion: convertDivElement,
	        priority: 1
	      }),
	      pre: node => ({
	        conversion: convertPreElement,
	        priority: 0
	      }),
	      table: node => {
	        const table = node;
	        // domNode is a <table> since we matched it by nodeName
	        if (isGitHubCodeTable(table)) {
	          return {
	            conversion: convertTableElement,
	            priority: 3
	          };
	        }
	        return null;
	      },
	      td: node => {
	        // element is a <td> since we matched it by nodeName
	        const td = node;
	        const table = td.closest('table');
	        if (isGitHubCodeCell(td)) {
	          return {
	            conversion: convertTableCellElement,
	            priority: 3
	          };
	        }
	        if (table && isGitHubCodeTable(table)) {
	          // Return a no-op if it's a table cell in a code table, but not a code line.
	          // Otherwise it'll fall back to the T
	          return {
	            conversion: convertCodeNoop,
	            priority: 3
	          };
	        }
	        return null;
	      },
	      tr: node => {
	        // element is a <tr> since we matched it by nodeName
	        const tr = node;
	        const table = tr.closest('table');
	        if (table && isGitHubCodeTable(table)) {
	          return {
	            conversion: convertCodeNoop,
	            priority: 3
	          };
	        }
	        return null;
	      }
	    };
	  }
	  static importJSON(serializedNode) {
	    const node = $createCodeNode();
	    node.setFormat(serializedNode.format);
	    node.setIndent(serializedNode.indent);
	    node.setDirection(serializedNode.direction);
	    return node;
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'code'
	    };
	  }
	  canIndent() {
	    return false;
	  }
	  canReplaceWith(replacement) {
	    return false;
	  }
	  isInline() {
	    return false;
	  }
	  collapseAtStart(selection) {
	    const paragraph = ui_lexical_core.$createParagraphNode();
	    const children = this.getChildren();
	    children.forEach(child => paragraph.append(child));
	    this.replace(paragraph);
	    return true;
	  }
	  insertNewAfter(selection, restoreSelection = true) {
	    const children = this.getChildren();
	    const childrenLength = children.length;
	    if (childrenLength >= 2 && children[childrenLength - 1].getTextContent() === '\n' && children[childrenLength - 2].getTextContent() === '\n' && selection.isCollapsed() && selection.anchor.key === this.__key && selection.anchor.offset === childrenLength) {
	      children[childrenLength - 1].remove();
	      children[childrenLength - 2].remove();
	      const newElement = ui_lexical_core.$createParagraphNode();
	      this.insertAfter(newElement, restoreSelection);
	      return newElement;
	    }

	    // If the selection is within the codeblock, find all leading tabs and
	    // spaces of the current line. Create a new line that has all those
	    // tabs and spaces, such that leading indentation is preserved.
	    const {
	      anchor,
	      focus
	    } = selection;
	    const firstPoint = anchor.isBefore(focus) ? anchor : focus;
	    const firstSelectionNode = firstPoint.getNode();
	    if (ui_lexical_core.$isTextNode(firstSelectionNode)) {
	      let node = getFirstCodeNodeOfLine(firstSelectionNode);
	      const insertNodes = [];
	      // eslint-disable-next-line no-constant-condition
	      while (true) {
	        if (ui_lexical_core.$isTabNode(node)) {
	          insertNodes.push(ui_lexical_core.$createTabNode());
	          node = node.getNextSibling();
	        } else if ($isCodeTokenNode(node)) {
	          let spaces = 0;
	          const text = node.getTextContent();
	          const textSize = node.getTextContentSize();
	          while (spaces < textSize && text[spaces] === ' ') {
	            spaces++;
	          }
	          if (spaces !== 0) {
	            insertNodes.push($createCodeTokenNode(' '.repeat(spaces)));
	          }
	          if (spaces !== textSize) {
	            break;
	          }
	          node = node.getNextSibling();
	        } else {
	          break;
	        }
	      }
	      const split = firstSelectionNode.splitText(anchor.offset)[0];
	      const x = anchor.offset === 0 ? 0 : 1;
	      const index = split.getIndexWithinParent() + x;
	      const codeNode = firstSelectionNode.getParentOrThrow();
	      const nodesToInsert = [ui_lexical_core.$createLineBreakNode(), ...insertNodes];
	      codeNode.splice(index, 0, nodesToInsert);
	      const last = insertNodes[insertNodes.length - 1];
	      if (last) {
	        last.select();
	      } else if (anchor.offset === 0) {
	        split.selectPrevious();
	      } else {
	        var _split$getNextSibling;
	        (_split$getNextSibling = split.getNextSibling()) == null ? void 0 : _split$getNextSibling.selectNext(0, 0);
	      }
	    }
	    if ($isCodeNode(firstSelectionNode)) {
	      const {
	        offset
	      } = selection.anchor;
	      firstSelectionNode.splice(offset, 0, [ui_lexical_core.$createLineBreakNode()]);
	      firstSelectionNode.select(offset + 1, offset + 1);
	    }
	    return null;
	  }
	}
	function $createCodeNode() {
	  return ui_lexical_core.$applyNodeReplacement(new CodeNode());
	}
	function $isCodeNode(node) {
	  return node instanceof CodeNode;
	}
	function convertPreElement(domNode) {
	  return {
	    node: $createCodeNode()
	  };
	}
	function convertDivElement(domNode) {
	  // domNode is a <div> since we matched it by nodeName
	  const div = domNode;
	  const isCode = isCodeElement(div);
	  if (!isCode && !isCodeChildElement(div)) {
	    return {
	      node: null
	    };
	  }
	  return {
	    after: childLexicalNodes => {
	      const domParent = domNode.parentNode;
	      if (domParent !== null && domNode !== domParent.lastChild) {
	        childLexicalNodes.push(ui_lexical_core.$createLineBreakNode());
	      }
	      return childLexicalNodes;
	    },
	    node: isCode ? $createCodeNode() : null
	  };
	}
	function convertTableElement() {
	  return {
	    node: $createCodeNode()
	  };
	}
	function convertCodeNoop() {
	  return {
	    node: null
	  };
	}
	function convertTableCellElement(domNode) {
	  // domNode is a <td> since we matched it by nodeName
	  const cell = domNode;
	  return {
	    after: childLexicalNodes => {
	      if (cell.parentNode && cell.parentNode.nextSibling) {
	        // Append newline between code lines
	        childLexicalNodes.push(ui_lexical_core.$createLineBreakNode());
	      }
	      return childLexicalNodes;
	    },
	    node: null
	  };
	}
	function isCodeElement(div) {
	  return div.style.fontFamily.match('monospace') !== null;
	}
	function isCodeChildElement(node) {
	  let parent = node.parentElement;
	  while (parent !== null) {
	    if (isCodeElement(parent)) {
	      return true;
	    }
	    parent = parent.parentElement;
	  }
	  return false;
	}
	function isGitHubCodeCell(cell) {
	  return cell.classList.contains('js-file-line');
	}
	function isGitHubCodeTable(table) {
	  return table.classList.contains('js-file-line-container');
	}
	function hasChildDOMNodeTag(node, tagName) {
	  let hasChild = false;
	  for (const child of node.childNodes) {
	    if (main_core.Type.isElementNode(child) && child.tagName === tagName) {
	      return true;
	    }
	    hasChild = hasChildDOMNodeTag(child, tagName);
	  }
	  return hasChild;
	}

	/* eslint-disable no-underscore-dangle */
	const FORMAT_CODE_COMMAND = ui_lexical_core.createCommand('FORMAT_CODE_COMMAND');
	const INSERT_CODE_COMMAND = ui_lexical_core.createCommand('INSERT_CODE_COMMAND');
	var _nodesCurrentlyHighlighting = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("nodesCurrentlyHighlighting");
	var _codeParser = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("codeParser");
	var _registerComponents$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _registerListeners$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _registerCommands$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _handleCodeNodeTransform = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCodeNodeTransform");
	var _handleTextNodeTransform = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleTextNodeTransform");
	var _handleTab = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleTab");
	var _handleMultilineIndent = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleMultilineIndent");
	class CodePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _handleMultilineIndent, {
	      value: _handleMultilineIndent2
	    });
	    Object.defineProperty(this, _handleTab, {
	      value: _handleTab2
	    });
	    Object.defineProperty(this, _handleTextNodeTransform, {
	      value: _handleTextNodeTransform2
	    });
	    Object.defineProperty(this, _handleCodeNodeTransform, {
	      value: _handleCodeNodeTransform2
	    });
	    Object.defineProperty(this, _registerCommands$3, {
	      value: _registerCommands2$3
	    });
	    Object.defineProperty(this, _registerListeners$1, {
	      value: _registerListeners2$1
	    });
	    Object.defineProperty(this, _registerComponents$2, {
	      value: _registerComponents2$2
	    });
	    Object.defineProperty(this, _nodesCurrentlyHighlighting, {
	      writable: true,
	      value: new Set()
	    });
	    Object.defineProperty(this, _codeParser, {
	      writable: true,
	      value: new ui_codeParser.CodeParser()
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$3)[_registerCommands$3]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$2)[_registerComponents$2]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$1)[_registerListeners$1]();
	  }
	  static getName() {
	    return 'Code';
	  }
	  static getNodes(editor) {
	    return [CodeNode, CodeTokenNode];
	  }
	  importBBCode() {
	    return {
	      code: () => ({
	        conversion: node => {
	          return {
	            node: $createCodeNode(),
	            after: childLexicalNodes => {
	              // const childNodes = trimLineBreaks(childLexicalNodes);
	              const content = childLexicalNodes.map(childNode => childNode.getTextContent()).join('');

	              // return getCodeTokenNodes(parse(content));
	              return [ui_lexical_core.$createTextNode(content)];
	            }
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      code: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'code'
	          })
	        };
	      },
	      'code-token': lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createText({
	            content: lexicalNode.getTextContent(),
	            encode: false
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: CodeNode
	      }],
	      bbcodeMap: {
	        code: 'code'
	      }
	    };
	  }
	}
	function _registerComponents2$2() {
	  this.getEditor().getComponentRegistry().register('code', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --enclose-text-in-code-tag"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_CODE'));
	    button.setBlockType('code');
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        if (button.isActive()) {
	          this.getEditor().dispatchCommand(FORMAT_PARAGRAPH_COMMAND);
	        } else {
	          this.getEditor().dispatchCommand(FORMAT_CODE_COMMAND);
	        }
	      });
	    });
	    return button;
	  });
	}
	function _registerListeners2$1() {
	  const handleTextNodeTransform = babelHelpers.classPrivateFieldLooseBase(this, _handleTextNodeTransform)[_handleTextNodeTransform].bind(this);
	  this.cleanUpRegister(
	  // Prevent formatting
	  this.getEditor().registerNodeTransform(CodeNode, babelHelpers.classPrivateFieldLooseBase(this, _handleCodeNodeTransform)[_handleCodeNodeTransform].bind(this)), this.getEditor().registerNodeTransform(ui_lexical_core.TextNode, handleTextNodeTransform), this.getEditor().registerNodeTransform(CodeTokenNode, handleTextNodeTransform), this.getEditor().registerCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    const node = getSelectedNode(selection);
	    // const parent = node.getParent();

	    return $isCodeTokenNode(node) || $isCodeNode(node);
	  }, ui_lexical_core.COMMAND_PRIORITY_HIGH), this.getEditor().registerCommand(ui_lexical_core.KEY_TAB_COMMAND, event => {
	    const command = babelHelpers.classPrivateFieldLooseBase(this, _handleTab)[_handleTab](event.shiftKey);
	    if (command === null) {
	      return false;
	    }
	    event.preventDefault();
	    this.getEditor().dispatchCommand(command);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.INSERT_TAB_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!$isSelectionInCode(selection)) {
	      return false;
	    }
	    ui_lexical_core.$insertNodes([ui_lexical_core.$createTabNode()]);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.INDENT_CONTENT_COMMAND, payload => babelHelpers.classPrivateFieldLooseBase(this, _handleMultilineIndent)[_handleMultilineIndent](ui_lexical_core.INDENT_CONTENT_COMMAND), ui_lexical_core.COMMAND_PRIORITY_NORMAL), this.getEditor().registerCommand(ui_lexical_core.OUTDENT_CONTENT_COMMAND, payload => babelHelpers.classPrivateFieldLooseBase(this, _handleMultilineIndent)[_handleMultilineIndent](ui_lexical_core.OUTDENT_CONTENT_COMMAND), ui_lexical_core.COMMAND_PRIORITY_NORMAL), this.getEditor().registerCommand(ui_lexical_core.PASTE_COMMAND, event => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) || !(event instanceof ClipboardEvent) || event.clipboardData === null) {
	      return false;
	    }
	    const codeNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => $isCodeNode(node));
	    if (codeNode) {
	      ui_lexical_clipboard.$insertDataTransferForPlainText(event.clipboardData, selection);
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_NORMAL));
	}
	function _registerCommands2$3() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_CODE_COMMAND, payload => {
	    const codeNode = $createCodeNode();
	    if (main_core.Type.isPlainObject(payload) && main_core.Type.isStringFilled(payload.content)) {
	      const tokenNodes = getCodeTokenNodes(babelHelpers.classPrivateFieldLooseBase(this, _codeParser)[_codeParser].parse(payload.content));
	      codeNode.append(...tokenNodes);
	      ui_lexical_utils.$insertNodeToNearestRoot(codeNode);
	    } else {
	      ui_lexical_utils.$insertNodeToNearestRoot(codeNode);
	      codeNode.selectEnd();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(FORMAT_CODE_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      if (selection.isCollapsed()) {
	        ui_lexical_selection.$setBlocksType(selection, () => $createCodeNode());
	      } else {
	        const textContent = selection.getTextContent();
	        const codeNode = $createCodeNode();
	        selection.insertNodes([codeNode]);
	        const newSelection = ui_lexical_core.$getSelection();
	        if (ui_lexical_core.$isRangeSelection(newSelection)) {
	          newSelection.insertRawText(textContent);
	        }
	      }
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR));
	}
	function _handleCodeNodeTransform2(node) {
	  const nodeKey = node.getKey();
	  if (babelHelpers.classPrivateFieldLooseBase(this, _nodesCurrentlyHighlighting)[_nodesCurrentlyHighlighting].has(nodeKey)) {
	    return;
	  }
	  babelHelpers.classPrivateFieldLooseBase(this, _nodesCurrentlyHighlighting)[_nodesCurrentlyHighlighting].add(nodeKey);

	  // Using nested update call to pass `skipTransforms` since we don't want
	  // each individual code-token node to be transformed again as it's already
	  // in its final state
	  this.getEditor().update(() => {
	    updateAndRetainSelection(nodeKey, () => {
	      const currentNode = ui_lexical_core.$getNodeByKey(nodeKey);
	      if (!$isCodeNode(currentNode) || !currentNode.isAttached()) {
	        return false;
	      }
	      const code = currentNode.getTextContent();
	      const codeTokenNodes = getCodeTokenNodes(babelHelpers.classPrivateFieldLooseBase(this, _codeParser)[_codeParser].parse(code));
	      const diffRange = getDiffRange(currentNode.getChildren(), codeTokenNodes);
	      const {
	        from,
	        to,
	        nodesForReplacement
	      } = diffRange;
	      if (from !== to || nodesForReplacement.length > 0) {
	        node.splice(from, to - from, nodesForReplacement);
	        return true;
	      }
	      return false;
	    });
	  }, {
	    onUpdate: () => {
	      babelHelpers.classPrivateFieldLooseBase(this, _nodesCurrentlyHighlighting)[_nodesCurrentlyHighlighting].delete(nodeKey);
	    },
	    skipTransforms: true
	  });
	}
	function _handleTextNodeTransform2(node) {
	  // Since CodeNode has flat children structure we only need to check
	  // if node's parent is a code node and run highlighting if so
	  const parentNode = node.getParent();
	  if ($isCodeNode(parentNode)) {
	    babelHelpers.classPrivateFieldLooseBase(this, _handleCodeNodeTransform)[_handleCodeNodeTransform](parentNode);
	  } else if ($isCodeTokenNode(node)) {
	    // When code block converted into paragraph or other element
	    // code token nodes converted back to normal text
	    node.replace(ui_lexical_core.$createTextNode(node.__text));
	  }
	}
	function _handleTab2(shiftKey) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || !$isSelectionInCode(selection)) {
	    return null;
	  }
	  const indentOrOutdent = shiftKey ? ui_lexical_core.OUTDENT_CONTENT_COMMAND : ui_lexical_core.INDENT_CONTENT_COMMAND;
	  const tabOrOutdent = shiftKey ? ui_lexical_core.OUTDENT_CONTENT_COMMAND : ui_lexical_core.INSERT_TAB_COMMAND;

	  // 1. If multiple lines selected: indent/outdent
	  const codeLines = $getCodeLines(selection);
	  if (codeLines.length > 1) {
	    return indentOrOutdent;
	  }

	  // 2. If entire line selected: indent/outdent
	  const selectionNodes = selection.getNodes();
	  const firstNode = selectionNodes[0];
	  if ($isCodeNode(firstNode)) {
	    return indentOrOutdent;
	  }
	  const firstOfLine = getFirstCodeNodeOfLine(firstNode);
	  const lastOfLine = getLastCodeNodeOfLine(firstNode);
	  const anchor = selection.anchor;
	  const focus = selection.focus;
	  let selectionFirst = null;
	  let selectionLast = null;
	  if (focus.isBefore(anchor)) {
	    selectionFirst = focus;
	    selectionLast = anchor;
	  } else {
	    selectionFirst = anchor;
	    selectionLast = focus;
	  }
	  if (firstOfLine !== null && lastOfLine !== null && selectionFirst.key === firstOfLine.getKey() && selectionFirst.offset === 0 && selectionLast.key === lastOfLine.getKey() && selectionLast.offset === lastOfLine.getTextContentSize()) {
	    return indentOrOutdent;
	  }

	  // 3. Else: tab/outdent
	  return tabOrOutdent;
	}
	function _handleMultilineIndent2(type) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || !$isSelectionInCode(selection)) {
	    return false;
	  }
	  const codeLines = $getCodeLines(selection);
	  const codeLinesLength = codeLines.length;
	  // Multiple lines selection
	  if (codeLines.length > 1) {
	    for (let i = 0; i < codeLinesLength; i++) {
	      const line = codeLines[i];
	      if (line.length > 0) {
	        let firstOfLine = line[0];
	        // First and last lines might not be complete
	        if (i === 0) {
	          firstOfLine = getFirstCodeNodeOfLine(firstOfLine);
	        }
	        if (firstOfLine !== null) {
	          if (type === ui_lexical_core.INDENT_CONTENT_COMMAND) {
	            // eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-dom-methods
	            firstOfLine.insertBefore(ui_lexical_core.$createTabNode());
	          } else if (ui_lexical_core.$isTabNode(firstOfLine)) {
	            firstOfLine.remove();
	          }
	        }
	      }
	    }
	    return true;
	  }

	  // Just one line
	  const selectionNodes = selection.getNodes();
	  const firstNode = selectionNodes[0];
	  if ($isCodeNode(firstNode)) {
	    // CodeNode is empty
	    if (type === ui_lexical_core.INDENT_CONTENT_COMMAND) {
	      selection.insertNodes([ui_lexical_core.$createTabNode()]);
	    }
	    return true;
	  }
	  const firstOfLine = getFirstCodeNodeOfLine(firstNode);
	  if (type === ui_lexical_core.INDENT_CONTENT_COMMAND) {
	    if (ui_lexical_core.$isLineBreakNode(firstOfLine)) {
	      firstOfLine.insertAfter(ui_lexical_core.$createTabNode());
	    } else {
	      // eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-dom-methods
	      firstOfLine.insertBefore(ui_lexical_core.$createTabNode());
	    }
	  } else if (ui_lexical_core.$isTabNode(firstOfLine)) {
	    firstOfLine.remove();
	  }
	  return true;
	}
	function $isSelectionInCode(selection) {
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return false;
	  }
	  const anchorNode = selection.anchor.getNode();
	  const focusNode = selection.focus.getNode();
	  if (anchorNode.is(focusNode) && $isCodeNode(anchorNode)) {
	    return true;
	  }
	  const anchorParent = anchorNode.getParent();
	  return $isCodeNode(anchorParent) && anchorParent.is(focusNode.getParent());
	}
	function $getCodeLines(selection) {
	  const nodes = selection.getNodes();
	  const lines = [[]];
	  if (nodes.length === 1 && $isCodeNode(nodes[0])) {
	    return lines;
	  }
	  let lastLine = lines[0];
	  for (const [i, node] of nodes.entries()) {
	    if (ui_lexical_core.$isLineBreakNode(node)) {
	      if (i !== 0 && lastLine.length > 0) {
	        lastLine = [];
	        lines.push(lastLine);
	      }
	    } else {
	      lastLine.push(node);
	    }
	  }
	  return lines;
	}
	function getFirstCodeNodeOfLine(anchor) {
	  let previousNode = anchor;
	  let node = anchor;
	  while ($isCodeTokenNode(node) || ui_lexical_core.$isTabNode(node)) {
	    previousNode = node;
	    node = node.getPreviousSibling();
	  }
	  return previousNode;
	}
	function getLastCodeNodeOfLine(anchor) {
	  let nextNode = anchor;
	  let node = anchor;
	  while ($isCodeTokenNode(node) || ui_lexical_core.$isTabNode(node)) {
	    nextNode = node;
	    node = node.getNextSibling();
	  }
	  return nextNode;
	}
	// Finds minimal diff range between two nodes lists. It returns from/to range boundaries of prevNodes
	// that needs to be replaced with `nodes` (subset of nextNodes) to make prevNodes equal to nextNodes.
	function getDiffRange(prevNodes, nextNodes) {
	  let leadingMatch = 0;
	  while (leadingMatch < prevNodes.length) {
	    if (!isEqual(prevNodes[leadingMatch], nextNodes[leadingMatch])) {
	      break;
	    }
	    leadingMatch++;
	  }
	  const prevNodesLength = prevNodes.length;
	  const nextNodesLength = nextNodes.length;
	  const maxTrailingMatch = Math.min(prevNodesLength, nextNodesLength) - leadingMatch;
	  let trailingMatch = 0;
	  while (trailingMatch < maxTrailingMatch) {
	    trailingMatch++;
	    if (!isEqual(prevNodes[prevNodesLength - trailingMatch], nextNodes[nextNodesLength - trailingMatch])) {
	      trailingMatch--;
	      break;
	    }
	  }
	  const from = leadingMatch;
	  const to = prevNodesLength - trailingMatch;
	  const nodesForReplacement = nextNodes.slice(leadingMatch, nextNodesLength - trailingMatch);
	  return {
	    from,
	    nodesForReplacement,
	    to
	  };
	}
	function isEqual(nodeA, nodeB) {
	  // Only checking for code token nodes, tabs and linebreaks. If it's regular text node
	  // returning false so that it's transformed into code token node
	  return $isCodeTokenNode(nodeA) && $isCodeTokenNode(nodeB) && nodeA.__text === nodeB.__text && nodeA.__highlightType === nodeB.__highlightType || ui_lexical_core.$isTabNode(nodeA) && ui_lexical_core.$isTabNode(nodeB) || ui_lexical_core.$isLineBreakNode(nodeA) && ui_lexical_core.$isLineBreakNode(nodeB);
	}
	function getCodeTokenNodes(tokens) {
	  const nodes = [];
	  tokens.forEach(token => {
	    const partials = token.content.split(/([\t\n])/);
	    const partialsLength = partials.length;
	    for (let i = 0; i < partialsLength; i++) {
	      const part = partials[i];
	      if (part === '\n' || part === '\r\n') {
	        nodes.push(ui_lexical_core.$createLineBreakNode());
	      } else if (part === '\t') {
	        nodes.push(ui_lexical_core.$createTabNode());
	      } else if (part.length > 0) {
	        nodes.push($createCodeTokenNode(part, token.type));
	      }
	    }
	  });
	  return nodes;
	}

	// Wrapping update function into selection retainer, that tries to keep cursor at the same
	// position as before.
	function updateAndRetainSelection(nodeKey, updateFn) {
	  const node = ui_lexical_core.$getNodeByKey(nodeKey);
	  if (!$isCodeNode(node) || !node.isAttached()) {
	    return;
	  }

	  // If it's not range selection (or null selection) there's no need to change it,
	  // but we can still run highlighting logic
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    updateFn();
	    return;
	  }
	  const anchor = selection.anchor;
	  const anchorOffset = anchor.offset;
	  const isNewLineAnchor = anchor.type === 'element' && ui_lexical_core.$isLineBreakNode(node.getChildAtIndex(anchor.offset - 1));

	  // Calculating previous text offset (all text node prior to anchor + anchor own text offset)
	  let textOffset = 0;
	  if (!isNewLineAnchor) {
	    const anchorNode = anchor.getNode();
	    textOffset = anchorOffset + anchorNode.getPreviousSiblings().reduce((offset, _node) => {
	      return offset + _node.getTextContentSize();
	    }, 0);
	  }
	  const hasChanges = updateFn();
	  if (!hasChanges) {
	    return;
	  }

	  // Non-text anchors only happen for line breaks, otherwise
	  // selection will be within text node (code token node)
	  if (isNewLineAnchor) {
	    anchor.getNode().select(anchorOffset, anchorOffset);
	    return;
	  }

	  // If it was non-element anchor then we walk through child nodes
	  // and looking for a position of original text offset
	  node.getChildren().some(child => {
	    const isText = ui_lexical_core.$isTextNode(child);
	    if (isText || ui_lexical_core.$isLineBreakNode(child)) {
	      const textContentSize = child.getTextContentSize();
	      if (isText && textContentSize >= textOffset) {
	        child.select(textOffset, textOffset);
	        return true;
	      }
	      textOffset -= textContentSize;
	    }
	    return false;
	  });
	}



	var Code = /*#__PURE__*/Object.freeze({
		FORMAT_CODE_COMMAND: FORMAT_CODE_COMMAND,
		INSERT_CODE_COMMAND: INSERT_CODE_COMMAND,
		CodePlugin: CodePlugin,
		getFirstCodeNodeOfLine: getFirstCodeNodeOfLine,
		getLastCodeNodeOfLine: getLastCodeNodeOfLine,
		CodeNode: CodeNode,
		$createCodeNode: $createCodeNode,
		$isCodeNode: $isCodeNode,
		CodeTokenNode: CodeTokenNode,
		$createCodeTokenNode: $createCodeTokenNode,
		$isCodeTokenNode: $isCodeTokenNode
	});

	function isNodeSelected(editor, key) {
	  return editor.getEditorState().read(() => {
	    const node = ui_lexical_core.$getNodeByKey(key);
	    if (node === null) {
	      return false;
	    }
	    return node.isSelected();
	  });
	}
	function createNodeSelection(editor, key) {
	  let isSelected = false;
	  const subscribers = new Set();
	  const onSelect = fn => {
	    subscribers.add(fn);
	  };
	  const unregisterListener = editor.registerUpdateListener(() => {
	    isSelected = isNodeSelected(editor, key);
	    for (const subscribeFunc of subscribers) {
	      subscribeFunc(isSelected);
	    }
	  });
	  const setSelected = selected => {
	    editor.update(() => {
	      let selection = ui_lexical_core.$getSelection();
	      if (!ui_lexical_core.$isNodeSelection(selection)) {
	        selection = ui_lexical_core.$createNodeSelection();
	        ui_lexical_core.$setSelection(selection);
	      }
	      if (selected) {
	        selection.add(key);
	      } else {
	        selection.delete(key);
	      }
	    });
	  };
	  const clearSelection = () => {
	    editor.update(() => {
	      const selection = ui_lexical_core.$getSelection();
	      if (ui_lexical_core.$isNodeSelection(selection)) {
	        selection.clear();
	      }
	    });
	  };
	  return {
	    isSelected: () => {
	      return isSelected;
	    },
	    dispose: () => {
	      unregisterListener();
	    },
	    onSelect,
	    setSelected,
	    clearSelection
	  };
	}

	var _textEditor$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("textEditor");
	var _target = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("target");
	var _nodeKey = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("nodeKey");
	var _options = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("options");
	var _nodeSelection = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("nodeSelection");
	var _unregisterCommands = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("unregisterCommands");
	var _registerCommands$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _handleDelete = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDelete");
	class DecoratorComponent {
	  constructor(componentOptions) {
	    Object.defineProperty(this, _handleDelete, {
	      value: _handleDelete2
	    });
	    Object.defineProperty(this, _registerCommands$4, {
	      value: _registerCommands2$4
	    });
	    Object.defineProperty(this, _textEditor$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _target, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _nodeKey, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _options, {
	      writable: true,
	      value: {}
	    });
	    Object.defineProperty(this, _nodeSelection, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _unregisterCommands, {
	      writable: true,
	      value: null
	    });
	    const {
	      textEditor,
	      target,
	      nodeKey,
	      options
	    } = componentOptions;
	    babelHelpers.classPrivateFieldLooseBase(this, _textEditor$1)[_textEditor$1] = textEditor;
	    babelHelpers.classPrivateFieldLooseBase(this, _target)[_target] = target;
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeKey)[_nodeKey] = nodeKey;
	    babelHelpers.classPrivateFieldLooseBase(this, _options)[_options] = options;
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection] = createNodeSelection(this.getEditor(), this.getNodeKey());
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].onSelect(selected => {
	      if (selected) {
	        main_core.Dom.addClass(this.getTarget(), '--selected');
	      } else {
	        main_core.Dom.removeClass(this.getTarget(), '--selected');
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _unregisterCommands)[_unregisterCommands] = babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$4)[_registerCommands$4]();
	  }
	  update(options) {
	    // update
	  }
	  destroy() {
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].dispose();
	    babelHelpers.classPrivateFieldLooseBase(this, _unregisterCommands)[_unregisterCommands]();
	  }
	  getEditor() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _textEditor$1)[_textEditor$1];
	  }
	  getNodeKey() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _nodeKey)[_nodeKey];
	  }
	  getTarget() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _target)[_target];
	  }
	  getNodeSelection() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection];
	  }
	  isSelected() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].isSelected();
	  }
	  setSelected(selected) {
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].setSelected(selected);
	  }
	  getOptions() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _options)[_options];
	  }
	  getOption(option, defaultValue) {
	    if (!main_core.Type.isUndefined(babelHelpers.classPrivateFieldLooseBase(this, _options)[_options][option])) {
	      return babelHelpers.classPrivateFieldLooseBase(this, _options)[_options][option];
	    }
	    if (!main_core.Type.isUndefined(defaultValue)) {
	      return defaultValue;
	    }
	    return null;
	  }
	}
	function _registerCommands2$4() {
	  return ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(ui_lexical_core.CLICK_COMMAND, event => {
	    if (this.getTarget().contains(event.target)) {
	      if (event.shiftKey) {
	        babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].setSelected(!babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].isSelected());
	      } else {
	        babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].clearSelection();
	        babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].setSelected(true);
	      }
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_DELETE_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleDelete)[_handleDelete].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_BACKSPACE_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleDelete)[_handleDelete].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _handleDelete2(event) {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].isSelected() && ui_lexical_core.$isNodeSelection(ui_lexical_core.$getSelection())) {
	    event.preventDefault();
	    const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	    babelHelpers.classPrivateFieldLooseBase(this, _nodeSelection)[_nodeSelection].setSelected(false);
	    if (node) {
	      node.remove();
	      return true;
	    }
	  }
	  return false;
	}

	let _$1 = t => t,
	  _t$1,
	  _t2;
	function clamp(value, min, max) {
	  return Math.min(Math.max(value, min), max);
	}
	const Direction = {
	  EAST: 1,
	  SOUTH: 2,
	  WEST: 4,
	  NORTH: 8
	};
	var _positioning = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("positioning");
	var _freeTransform = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("freeTransform");
	var _onPointerDownHandler = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onPointerDownHandler");
	var _onPointerMoveHandler = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onPointerMoveHandler");
	var _onPointerUpHandler = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onPointerUpHandler");
	var _container$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("container");
	var _target$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("target");
	var _editor = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("editor");
	var _maxWidth = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("maxWidth");
	var _maxHeight = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("maxHeight");
	var _minWidth = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("minWidth");
	var _minHeight = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("minHeight");
	var _handlePointerDown = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handlePointerDown");
	var _handlePointerMove = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handlePointerMove");
	var _handlePointerUp = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handlePointerUp");
	var _getMaxContainerWidth = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getMaxContainerWidth");
	var _getMaxContainerHeight = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getMaxContainerHeight");
	class FigureResizer extends main_core_events.EventEmitter {
	  constructor({
	    target: _target2,
	    editor,
	    originalWidth,
	    originalHeight,
	    minWidth,
	    minHeight,
	    maxWidth: _maxWidth2,
	    maxHeight,
	    events,
	    freeTransform
	  }) {
	    super();
	    Object.defineProperty(this, _getMaxContainerHeight, {
	      value: _getMaxContainerHeight2
	    });
	    Object.defineProperty(this, _getMaxContainerWidth, {
	      value: _getMaxContainerWidth2
	    });
	    Object.defineProperty(this, _handlePointerUp, {
	      value: _handlePointerUp2
	    });
	    Object.defineProperty(this, _handlePointerMove, {
	      value: _handlePointerMove2
	    });
	    Object.defineProperty(this, _handlePointerDown, {
	      value: _handlePointerDown2
	    });
	    Object.defineProperty(this, _positioning, {
	      writable: true,
	      value: {
	        currentHeight: 0,
	        currentWidth: 0,
	        direction: 0,
	        isResizing: false,
	        ratio: 0,
	        startHeight: 0,
	        startWidth: 0,
	        startX: 0,
	        startY: 0
	      }
	    });
	    Object.defineProperty(this, _freeTransform, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _onPointerDownHandler, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onPointerMoveHandler, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onPointerUpHandler, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _container$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _target$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _editor, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _maxWidth, {
	      writable: true,
	      value: 'none'
	    });
	    Object.defineProperty(this, _maxHeight, {
	      writable: true,
	      value: 'none'
	    });
	    Object.defineProperty(this, _minWidth, {
	      writable: true,
	      value: 16
	    });
	    Object.defineProperty(this, _minHeight, {
	      writable: true,
	      value: 16
	    });
	    this.setEventNamespace('BX.UI.TextEditor.FigureResizer');
	    babelHelpers.classPrivateFieldLooseBase(this, _target$1)[_target$1] = _target2;
	    babelHelpers.classPrivateFieldLooseBase(this, _editor)[_editor] = editor;
	    babelHelpers.classPrivateFieldLooseBase(this, _minWidth)[_minWidth] = Math.min(Math.max(babelHelpers.classPrivateFieldLooseBase(this, _minWidth)[_minWidth], main_core.Type.isNumber(minWidth) ? minWidth : babelHelpers.classPrivateFieldLooseBase(this, _minWidth)[_minWidth]), main_core.Type.isNumber(originalWidth) ? originalWidth : Infinity);
	    babelHelpers.classPrivateFieldLooseBase(this, _minHeight)[_minHeight] = Math.min(Math.max(babelHelpers.classPrivateFieldLooseBase(this, _minHeight)[_minHeight], main_core.Type.isNumber(minHeight) ? minHeight : babelHelpers.classPrivateFieldLooseBase(this, _minHeight)[_minHeight]), main_core.Type.isNumber(originalHeight) ? originalHeight : Infinity);
	    babelHelpers.classPrivateFieldLooseBase(this, _maxWidth)[_maxWidth] = main_core.Type.isNumber(_maxWidth2) ? _maxWidth2 : 'none';
	    babelHelpers.classPrivateFieldLooseBase(this, _maxHeight)[_maxHeight] = main_core.Type.isNumber(maxHeight) ? maxHeight : 'none';
	    babelHelpers.classPrivateFieldLooseBase(this, _freeTransform)[_freeTransform] = freeTransform === true;
	    babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler] = babelHelpers.classPrivateFieldLooseBase(this, _handlePointerDown)[_handlePointerDown].bind(this);
	    babelHelpers.classPrivateFieldLooseBase(this, _onPointerMoveHandler)[_onPointerMoveHandler] = babelHelpers.classPrivateFieldLooseBase(this, _handlePointerMove)[_handlePointerMove].bind(this);
	    babelHelpers.classPrivateFieldLooseBase(this, _onPointerUpHandler)[_onPointerUpHandler] = babelHelpers.classPrivateFieldLooseBase(this, _handlePointerUp)[_handlePointerUp].bind(this);
	    this.subscribeFromOptions(events);
	  }
	  show() {
	    main_core.Dom.addClass(this.getContainer(), '--shown');
	  }
	  hide() {
	    main_core.Dom.removeClass(this.getContainer(), '--shown');
	  }
	  getContainer() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _container$1)[_container$1] === null) {
	      const freeTransform = main_core.Tag.render(_t$1 || (_t$1 = _$1`
				<div
					class="ui-text-editor-figure-resizer-handle --north"
					data-direction="${0}"
					onpointerdown="${0}"
					></div>
				<div
					class="ui-text-editor-figure-resizer-handle --east"
					data-direction="${0}"
					onpointerdown="${0}"
					></div>
				<div
					class="ui-text-editor-figure-resizer-handle --south"
					data-direction="${0}"
					onpointerdown="${0}"
					></div>
				<div
					class="ui-text-editor-figure-resizer-handle --west"
					data-direction="${0}"
					onpointerdown="${0}"
					></div>
			`), Direction.NORTH, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.EAST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.SOUTH, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.WEST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler]);
	      babelHelpers.classPrivateFieldLooseBase(this, _container$1)[_container$1] = main_core.Tag.render(_t2 || (_t2 = _$1`
				<div class="ui-text-editor-figure-resizer">
					<div
						class="ui-text-editor-figure-resizer-handle --north-east"
						data-direction="${0}" 
						onpointerdown="${0}"
					></div>
					<div
						class="ui-text-editor-figure-resizer-handle --south-east"
						data-direction="${0}" 
						onpointerdown="${0}"
						></div>
					<div
						class="ui-text-editor-figure-resizer-handle --south-west"
						data-direction="${0}" 
						onpointerdown="${0}"
						></div>
					<div 
						class="ui-text-editor-figure-resizer-handle --north-west"
						data-direction="${0}" 
						onpointerdown="${0}"
						></div>
					${0}
				</div>
			`), Direction.NORTH | Direction.EAST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.SOUTH | Direction.EAST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.SOUTH | Direction.WEST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], Direction.NORTH | Direction.WEST, babelHelpers.classPrivateFieldLooseBase(this, _onPointerDownHandler)[_onPointerDownHandler], babelHelpers.classPrivateFieldLooseBase(this, _freeTransform)[_freeTransform] ? freeTransform : null);
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _container$1)[_container$1];
	  }
	  getTarget() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _target$1)[_target$1];
	  }
	  setTarget(target) {
	    babelHelpers.classPrivateFieldLooseBase(this, _target$1)[_target$1] = target;
	  }
	  getEditor() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _editor)[_editor];
	  }
	  isResizing() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].isResizing;
	  }
	}
	function _handlePointerDown2(event) {
	  if (!this.getEditor().isEditable()) {
	    return;
	  }
	  event.preventDefault();
	  const direction = Number(event.target.dataset.direction);
	  const target = this.getTarget();
	  const {
	    width,
	    height
	  } = target.getBoundingClientRect();
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startWidth = width;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startHeight = height;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].ratio = width / height;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth = width;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight = height;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startX = event.clientX;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startY = event.clientY;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].isResizing = true;
	  babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction = direction;

	  // setStartCursor(direction);
	  this.emit('onResizeStart');
	  main_core.Dom.addClass(this.getContainer(), '--resizing');
	  main_core.Dom.style(target, {
	    width: `${width}px`,
	    height: `${height}px`
	  });
	  main_core.Event.bind(document, 'pointermove', babelHelpers.classPrivateFieldLooseBase(this, _onPointerMoveHandler)[_onPointerMoveHandler]);
	  main_core.Event.bind(document, 'pointerup', babelHelpers.classPrivateFieldLooseBase(this, _onPointerUpHandler)[_onPointerUpHandler]);
	}
	function _handlePointerMove2(event) {
	  const target = this.getTarget();
	  const isHorizontal = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction & (Direction.EAST | Direction.WEST);
	  const isVertical = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction & (Direction.SOUTH | Direction.NORTH);
	  if (babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].isResizing) {
	    // Corner cursor
	    if (isHorizontal && isVertical) {
	      let diff = Math.floor(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startX - event.clientX);
	      diff = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction & Direction.EAST ? -diff : diff;
	      const width = Math.round(clamp(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startWidth + diff, babelHelpers.classPrivateFieldLooseBase(this, _minWidth)[_minWidth], babelHelpers.classPrivateFieldLooseBase(this, _getMaxContainerWidth)[_getMaxContainerWidth]()));
	      const height = Math.ceil(width / babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].ratio);
	      main_core.Dom.style(target, {
	        width: `${width}px`,
	        height: `${height}px`
	      });
	      this.emit('onResize', {
	        width,
	        height
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight = height;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth = width;
	    } else if (isVertical) {
	      let diff = Math.floor(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startY - event.clientY);
	      diff = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction & Direction.SOUTH ? -diff : diff;
	      const height = Math.round(Math.max(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startHeight + diff, babelHelpers.classPrivateFieldLooseBase(this, _minHeight)[_minHeight] // this.#getMaxContainerHeight(),
	      ));
	      main_core.Dom.style(target, 'height', `${height}px`);
	      this.emit('onResize', {
	        width: babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth,
	        height
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight = height;
	    } else {
	      let diff = Math.floor(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startX - event.clientX);
	      diff = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].direction & Direction.EAST ? -diff : diff;
	      const width = Math.round(clamp(babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startWidth + diff, babelHelpers.classPrivateFieldLooseBase(this, _minWidth)[_minWidth], babelHelpers.classPrivateFieldLooseBase(this, _getMaxContainerWidth)[_getMaxContainerWidth]()));
	      main_core.Dom.style(target, 'width', `${width}px`);
	      this.emit('onResize', {
	        width,
	        height: babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth = width;
	    }
	  }
	}
	function _handlePointerUp2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].isResizing) {
	    setTimeout(() => {
	      const width = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth;
	      const height = babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startWidth = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startHeight = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].ratio = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startX = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].startY = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentWidth = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].currentHeight = 0;
	      babelHelpers.classPrivateFieldLooseBase(this, _positioning)[_positioning].isResizing = false;
	      main_core.Dom.removeClass(this.getContainer(), '--resizing');
	      this.emit('onResizeEnd', {
	        width,
	        height
	      });
	      // setEndCursor();

	      main_core.Event.unbind(document, 'pointermove', babelHelpers.classPrivateFieldLooseBase(this, _onPointerMoveHandler)[_onPointerMoveHandler]);
	      main_core.Event.unbind(document, 'pointerup', babelHelpers.classPrivateFieldLooseBase(this, _onPointerUpHandler)[_onPointerUpHandler]);
	    }, 200);
	  }
	}
	function _getMaxContainerWidth2() {
	  const maxWidth = main_core.Type.isNumber(babelHelpers.classPrivateFieldLooseBase(this, _maxWidth)[_maxWidth]) ? babelHelpers.classPrivateFieldLooseBase(this, _maxWidth)[_maxWidth] : Infinity;
	  const editorRootElement = this.getEditor().getRootElement();
	  if (editorRootElement !== null) {
	    return Math.min(editorRootElement.getBoundingClientRect().width - 20, maxWidth);
	  }
	  return 100;
	}
	function _getMaxContainerHeight2() {
	  if (main_core.Type.isNumber(babelHelpers.classPrivateFieldLooseBase(this, _maxHeight)[_maxHeight])) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _maxHeight)[_maxHeight];
	  }
	  const editorRootElement = this.getEditor().getRootElement();
	  if (editorRootElement !== null) {
	    return editorRootElement.getBoundingClientRect().height - 20;
	  }
	  return 100;
	}

	let _$2 = t => t,
	  _t$2,
	  _t2$1;
	var _refs = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _figureResizer = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("figureResizer");
	var _render = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("render");
	var _getContainer = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getContainer");
	var _getImageContainer = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getImageContainer");
	var _setDraggable = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("setDraggable");
	var _handleResizeStart = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeStart");
	var _handleResizeEnd = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeEnd");
	class FileImageComponent extends DecoratorComponent {
	  constructor(options) {
	    super(options);
	    Object.defineProperty(this, _handleResizeEnd, {
	      value: _handleResizeEnd2
	    });
	    Object.defineProperty(this, _handleResizeStart, {
	      value: _handleResizeStart2
	    });
	    Object.defineProperty(this, _setDraggable, {
	      value: _setDraggable2
	    });
	    Object.defineProperty(this, _getImageContainer, {
	      value: _getImageContainer2
	    });
	    Object.defineProperty(this, _getContainer, {
	      value: _getContainer2
	    });
	    Object.defineProperty(this, _render, {
	      value: _render2
	    });
	    Object.defineProperty(this, _refs, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _figureResizer, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer] = new FigureResizer({
	      target: this.getImage(),
	      editor: this.getEditor(),
	      originalWidth: this.getOption('width'),
	      originalHeight: this.getOption('height'),
	      events: {
	        onResizeStart: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeStart)[_handleResizeStart].bind(this),
	        onResizeEnd: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeEnd)[_handleResizeEnd].bind(this)
	      }
	    });
	    this.getNodeSelection().onSelect(selected => {
	      if (selected || babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer].isResizing()) {
	        main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer)[_getContainer](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer].show();
	      } else {
	        main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer)[_getContainer](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer].hide();
	      }
	      const draggable = selected && !babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer].isResizing();
	      babelHelpers.classPrivateFieldLooseBase(this, _setDraggable)[_setDraggable](draggable);
	    });
	    this.update(this.getOptions());
	    babelHelpers.classPrivateFieldLooseBase(this, _render)[_render]();
	  }
	  getImage() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs)[_refs].remember('image', () => {
	      var _config$theme, _config$theme$image;
	      const img = document.createElement('img');
	      img.draggable = false;
	      img.src = this.getOption('src');
	      const config = this.getOption('config', {});
	      if (config != null && (_config$theme = config.theme) != null && (_config$theme$image = _config$theme.image) != null && _config$theme$image.img) {
	        img.className = config.theme.image.img;
	      }
	      return img;
	    });
	  }
	  update(options) {
	    const width = options.width > 0 ? `${options.width}px` : 'inherit';
	    const aspectRatio = options.width > 0 && options.height > 0 ? `${options.width} / ${options.height}` : 'auto';
	    main_core.Dom.style(this.getImage(), {
	      width,
	      height: 'auto',
	      aspectRatio
	    });
	  }
	}
	function _render2() {
	  main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _getContainer)[_getContainer](), this.getTarget());
	}
	function _getContainer2() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs)[_refs].remember('container', () => {
	    const figureResizer = babelHelpers.classPrivateFieldLooseBase(this, _figureResizer)[_figureResizer].getContainer();
	    return main_core.Tag.render(_t$2 || (_t$2 = _$2`
				<div class="ui-text-editor-file-image-component">
					${0}
					${0}
				</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _getImageContainer)[_getImageContainer](), figureResizer);
	  });
	}
	function _getImageContainer2() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs)[_refs].remember('image-container', () => {
	    return main_core.Tag.render(_t2$1 || (_t2$1 = _$2`
				<div class="ui-text-editor-file-image-container">
					${0}
				</div>
			`), this.getImage());
	  });
	}
	function _setDraggable2(draggable) {
	  main_core.Dom.attr(babelHelpers.classPrivateFieldLooseBase(this, _getImageContainer)[_getImageContainer](), {
	    draggable
	  });
	  if (draggable) {
	    main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer)[_getContainer](), '--draggable');
	  } else {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer)[_getContainer](), '--draggable');
	  }
	}
	function _handleResizeStart2(event) {
	  babelHelpers.classPrivateFieldLooseBase(this, _setDraggable)[_setDraggable](false);
	  this.setSelected(true);
	}
	function _handleResizeEnd2(event) {
	  this.setSelected(true);
	  this.getEditor().update(() => {
	    const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	    if ($isFileImageNode(node)) {
	      const {
	        width,
	        height
	      } = event.getData();
	      node.setWidthAndHeight(width, height);
	    }
	  });
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */

	/** @memberof BX.UI.TextEditor.Plugins.File */
	class FileImageNode extends ui_lexical_core.DecoratorNode {
	  constructor(serverFileId, info, width, height, key) {
	    super(key);
	    this.__serverFileId = serverFileId;
	    this.__info = main_core.Type.isPlainObject(info) ? info : {};
	    this.__width = main_core.Type.isNumber(width) && width > 0 ? Math.round(width) : this.__info.previewWidth;
	    this.__height = main_core.Type.isNumber(height) && height > 0 ? Math.round(height) : this.__info.previewHeight;
	  }
	  static getType() {
	    return 'file-image';
	  }
	  static clone(node) {
	    return new FileImageNode(node.__serverFileId, node.__info, node.__width, node.__height, node.__key);
	  }
	  getId() {
	    return this.__serverFileId;
	  }
	  getServerFileId() {
	    return this.__serverFileId;
	  }
	  getInfo() {
	    return this.__info;
	  }
	  setWidthAndHeight(width, height) {
	    const writable = this.getWritable();
	    if (main_core.Type.isNumber(width)) {
	      writable.__width = Math.round(width);
	    }
	    if (main_core.Type.isNumber(height)) {
	      writable.__height = Math.round(height);
	    }
	  }
	  getWidth() {
	    const self = this.getLatest();
	    return self.__width;
	  }
	  getHeight() {
	    const self = this.getLatest();
	    return self.__height;
	  }
	  isResized() {
	    return this.__info.previewWidth !== this.getWidth() || this.__info.previewHeight !== this.getHeight();
	  }
	  static importJSON(serializedNode) {
	    return $createFileImageNode(serializedNode.serverFileId, serializedNode.info, serializedNode.width, serializedNode.height);
	  }
	  static importDOM() {
	    return {
	      img: domNode => {
	        if (!domNode.hasAttribute('data-file-image-id')) {
	          return null;
	        }
	        return {
	          conversion: img => {
	            const {
	              fileImageId,
	              fileImageInfo
	            } = img.dataset;
	            let info = null;
	            try {
	              info = JSON.parse(fileImageInfo);
	            } catch {
	              return null;
	            }
	            const node = $createFileImageNode(fileImageId, info);
	            return {
	              node
	            };
	          },
	          priority: 1
	        };
	      }
	    };
	  }
	  exportDOM() {
	    return {
	      element: null
	    };
	  }
	  exportJSON() {
	    return {
	      info: this.__info,
	      serverFileId: this.__serverFileId,
	      width: this.getWidth(),
	      height: this.getHeight(),
	      type: 'file-image',
	      version: 1
	    };
	  }
	  createDOM(config, editor) {
	    var _config$theme, _config$theme$image;
	    const span = document.createElement('span');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : (_config$theme$image = _config$theme.image) == null ? void 0 : _config$theme$image.container)) {
	      main_core.Dom.addClass(span, config.theme.image.container);
	    }
	    return span;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	  decorate(editor, config) {
	    return {
	      componentClass: FileImageComponent,
	      options: {
	        src: this.__info.previewUrl,
	        width: this.getWidth(),
	        height: this.getHeight(),
	        maxWidth: this.getWidth(),
	        maxHeight: this.getHeight(),
	        config
	        // maxWidth: this.__info.previewWidth,
	        // maxHeight: this.__info.previewHeight,
	      }
	    };
	  }

	  isInline() {
	    return true;
	  }
	}
	FileImageNode.useDecoratorComponent = true;
	function $createFileImageNode(serverFileId, info = {}, width = null, height = null) {
	  return new FileImageNode(serverFileId, info, width, height);
	}
	function $isFileImageNode(node) {
	  return node instanceof FileImageNode;
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */

	/** @memberof BX.UI.TextEditor.Plugins.File */
	class FileNode extends ui_lexical_core.TextNode {
	  constructor(serverFileId, info, key) {
	    const fileInfo = main_core.Type.isPlainObject(info) ? info : {};
	    super(fileInfo.name || '', key);
	    this.__serverFileId = serverFileId;
	    this.__info = fileInfo;
	  }
	  static getType() {
	    return 'file';
	  }
	  static clone(node) {
	    return new FileNode(node.__serverFileId, node.__info, node.__key);
	  }
	  getId() {
	    return this.__serverFileId;
	  }
	  getServerFileId() {
	    return this.__serverFileId;
	  }
	  getInfo() {
	    return this.__info;
	  }
	  getName() {
	    return this.__info.name || 'unknown';
	  }
	  static importJSON(serializedNode) {
	    return $createFileNode(serializedNode.serverFileId, serializedNode.info);
	  }
	  static importDOM() {
	    return {
	      span: domNode => {
	        if (!domNode.hasAttribute('data-file-id')) {
	          return null;
	        }
	        return {
	          conversion: span => {
	            const {
	              fileId,
	              fileInfo
	            } = domNode.dataset;
	            let info = null;
	            try {
	              info = JSON.parse(fileInfo);
	            } catch {
	              return null;
	            }
	            const node = $createFileNode(fileId, info);
	            return {
	              node
	            };
	          },
	          priority: 1
	        };
	      }
	    };
	  }
	  exportDOM() {
	    const element = document.createElement('span');
	    element.textContent = this.getName();
	    element.setAttribute('data-file-id', this.__serverFileId);
	    element.setAttribute('data-file-info', JSON.stringify(this.__info));
	    return {
	      element
	    };
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      info: this.__info,
	      serverFileId: this.__serverFileId,
	      type: 'file',
	      version: 1
	    };
	  }
	  createDOM(config, editor) {
	    var _config$theme;
	    const span = document.createElement('span');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.file)) {
	      main_core.Dom.addClass(span, config.theme.file);
	    }
	    span.textContent = this.getName();
	    return span;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	}
	function $createFileNode(serverFileId, info = {}) {
	  return new FileNode(serverFileId, info).setMode('token');
	}
	function $isFileNode(node) {
	  return node instanceof FileNode;
	}

	function calcImageSize(previewWidth, previewHeight, renderWidth, renderHeight) {
	  const ratioWidth = renderWidth / previewWidth;
	  const ratioHeight = renderHeight / previewHeight;
	  const ratio = Math.min(ratioWidth, ratioHeight);
	  const useOriginalSize = ratio > 1; // image is too small
	  const width = useOriginalSize ? previewWidth : previewWidth * ratio;
	  const height = useOriginalSize ? previewHeight : previewHeight * ratio;
	  return [width, height];
	}

	let _$3 = t => t,
	  _t$3;
	var _refs$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _figureResizer$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("figureResizer");
	var _render$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("render");
	var _getContainer$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getContainer");
	var _getVideo = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getVideo");
	var _handleResize = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResize");
	var _handleResizeEnd$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeEnd");
	var _setDraggable$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("setDraggable");
	class FileVideoComponent extends DecoratorComponent {
	  constructor(options) {
	    super(options);
	    Object.defineProperty(this, _setDraggable$1, {
	      value: _setDraggable2$1
	    });
	    Object.defineProperty(this, _handleResizeEnd$1, {
	      value: _handleResizeEnd2$1
	    });
	    Object.defineProperty(this, _handleResize, {
	      value: _handleResize2
	    });
	    Object.defineProperty(this, _getVideo, {
	      value: _getVideo2
	    });
	    Object.defineProperty(this, _getContainer$1, {
	      value: _getContainer2$1
	    });
	    Object.defineProperty(this, _render$1, {
	      value: _render2$1
	    });
	    Object.defineProperty(this, _refs$1, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _figureResizer$1, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$1)[_figureResizer$1] = new FigureResizer({
	      target: babelHelpers.classPrivateFieldLooseBase(this, _getVideo)[_getVideo](),
	      editor: this.getEditor(),
	      minWidth: 120,
	      minHeight: 120,
	      events: {
	        onResize: babelHelpers.classPrivateFieldLooseBase(this, _handleResize)[_handleResize].bind(this),
	        onResizeEnd: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeEnd$1)[_handleResizeEnd$1].bind(this)
	      }
	    });
	    this.getNodeSelection().onSelect(selected => {
	      if (selected || babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$1)[_figureResizer$1].isResizing()) {
	        main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$1)[_figureResizer$1].show();
	      } else {
	        main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$1)[_figureResizer$1].hide();
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _setDraggable$1)[_setDraggable$1](selected);
	    });
	    this.update(this.getOptions());
	    babelHelpers.classPrivateFieldLooseBase(this, _render$1)[_render$1]();
	  }
	  update(options) {
	    const width = main_core.Type.isNumber(options.width) && options.width > 0 ? options.width : null;
	    const height = main_core.Type.isNumber(options.height) && options.height > 0 ? options.height : null;
	    const aspectRatio = width > 0 && height > 0 ? `${width} / ${height}` : 'auto';
	    main_core.Dom.adjust(babelHelpers.classPrivateFieldLooseBase(this, _getVideo)[_getVideo](), {
	      attrs: {
	        width,
	        height: null
	      },
	      style: {
	        width,
	        height: 'auto',
	        aspectRatio
	      }
	    });
	  }
	}
	function _render2$1() {
	  main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), this.getTarget());
	}
	function _getContainer2$1() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$1)[_refs$1].remember('container', () => {
	    return main_core.Tag.render(_t$3 || (_t$3 = _$3`
				<div class="ui-text-editor-video-component">
					<div class="ui-text-editor-video-object-container">${0}</div>
					${0}
				</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _getVideo)[_getVideo](), babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$1)[_figureResizer$1].getContainer());
	  });
	}
	function _getVideo2() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$1)[_refs$1].remember('video', () => {
	    var _config$theme, _config$theme$video;
	    const video = main_core.Dom.create({
	      tag: 'video',
	      attrs: {
	        controls: true,
	        preload: 'metadata',
	        playsinline: true,
	        src: this.getOption('src')
	      },
	      events: {
	        loadedmetadata: event => {
	          this.getEditor().update(() => {
	            const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	            if ($isFileVideoNode(node) && node.getWidth() === 0) {
	              const [width, height] = calcImageSize(event.target.videoWidth, event.target.videoHeight, 600, 600);
	              node.setWidthAndHeight(width, height);
	            }
	          });
	        }
	      }
	    });
	    const config = this.getOption('config', {});
	    if (config != null && (_config$theme = config.theme) != null && (_config$theme$video = _config$theme.video) != null && _config$theme$video.object) {
	      video.className = config.theme.video.object;
	    }
	    return video;
	  });
	}
	function _handleResize2(event) {
	  this.update(event.getData());
	}
	function _handleResizeEnd2$1(event) {
	  this.setSelected(true);
	  this.getEditor().update(() => {
	    const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	    if ($isFileVideoNode(node)) {
	      const {
	        width,
	        height
	      } = event.getData();
	      node.setWidthAndHeight(width, height);
	    }
	  });
	}
	function _setDraggable2$1(draggable) {
	  main_core.Dom.attr(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), {
	    draggable
	  });
	  if (draggable) {
	    main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), '--draggable');
	  } else {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$1)[_getContainer$1](), '--draggable');
	  }
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */

	/** @memberof BX.UI.TextEditor.Plugins.File */
	class FileVideoNode extends ui_lexical_core.DecoratorNode {
	  constructor(serverFileId, info, width, height, key) {
	    super(key);
	    this.__width = 0;
	    this.__height = 0;
	    this.__serverFileId = serverFileId;
	    this.__info = main_core.Type.isPlainObject(info) ? info : {};
	    this.__width = main_core.Type.isNumber(width) && width > 0 ? Math.round(width) : this.__info.previewWidth > 0 ? this.__info.previewWidth : this.__width;
	    this.__height = main_core.Type.isNumber(height) && height > 0 ? Math.round(height) : this.__info.previewHeight > 0 ? this.__info.previewHeight : this.__height;
	  }
	  static getType() {
	    return 'file-video';
	  }
	  static clone(node) {
	    return new FileVideoNode(node.__serverFileId, node.__info, node.__width, node.__height, node.__key);
	  }
	  getId() {
	    return this.__serverFileId;
	  }
	  getServerFileId() {
	    return this.__serverFileId;
	  }
	  getInfo() {
	    return this.__info;
	  }
	  setWidthAndHeight(width, height) {
	    const writable = this.getWritable();
	    if (main_core.Type.isNumber(width)) {
	      writable.__width = Math.round(width);
	    }
	    if (main_core.Type.isNumber(height)) {
	      writable.__height = Math.round(height);
	    }
	  }
	  getWidth() {
	    const self = this.getLatest();
	    return self.__width;
	  }
	  getHeight() {
	    const self = this.getLatest();
	    return self.__height;
	  }
	  static importJSON(serializedNode) {
	    return $createFileVideoNode(serializedNode.serverFileId, serializedNode.info, serializedNode.width, serializedNode.height);
	  }
	  static importDOM() {
	    return null;
	  }
	  exportDOM() {
	    return {
	      element: null
	    };
	  }
	  exportJSON() {
	    return {
	      info: this.__info,
	      serverFileId: this.__serverFileId,
	      width: this.getWidth(),
	      height: this.getHeight(),
	      type: 'file-video',
	      version: 1
	    };
	  }
	  createDOM(config, editor) {
	    var _config$theme, _config$theme$video;
	    const div = document.createElement('span');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : (_config$theme$video = _config$theme.video) == null ? void 0 : _config$theme$video.container)) {
	      main_core.Dom.addClass(div, config.theme.video.container);
	    }
	    return div;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	  decorate(editor, config) {
	    return {
	      componentClass: FileVideoComponent,
	      options: {
	        src: this.__info.downloadUrl,
	        width: this.getWidth(),
	        height: this.getHeight(),
	        maxWidth: this.getWidth(),
	        maxHeight: this.getHeight(),
	        config
	      }
	    };
	  }
	  isInline() {
	    return true;
	  }
	}
	FileVideoNode.useDecoratorComponent = true;
	function $createFileVideoNode(serverFileId, info = {}, width = null, height = null) {
	  const node = new FileVideoNode(serverFileId, info, width, height);
	  return ui_lexical_core.$applyNodeReplacement(node);
	}
	function $isFileVideoNode(node) {
	  return node instanceof FileVideoNode;
	}

	function getDragSelection(event) {
	  const target = event.target;
	  let targetWindow = null;
	  if (target !== null) {
	    targetWindow = target.nodeType === 9 ? target.defaultView : target.ownerDocument.defaultView;
	  }
	  let range = null;
	  const domSelection = (targetWindow || window).getSelection();
	  if (document.caretRangeFromPoint) {
	    range = document.caretRangeFromPoint(event.clientX, event.clientY);
	  } else if (event.rangeParent && domSelection !== null) {
	    domSelection.collapse(event.rangeParent, event.rangeOffset || 0);
	    range = domSelection.getRangeAt(0);
	  } else {
	    throw new Error('Cannot get the selection when dragging');
	  }
	  return range;
	}

	function getNodeInSelection(predicate) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isNodeSelection(selection)) {
	    return null;
	  }
	  const nodes = selection.getNodes();
	  const node = nodes[0];
	  return predicate(node) ? node : null;
	}

	let _$4 = t => t,
	  _t$4;
	const DRAG_DATA_FORMAT = 'application/x-lexical-drag-image';
	const TRANSPARENT_IMAGE = main_core.Tag.render(_t$4 || (_t$4 = _$4`<img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7">`));
	function registerDraggableNode(editor, targetNode, onDrop) {
	  const isTargetNode = node => {
	    return node instanceof targetNode;
	  };
	  const getDraggableNode = () => {
	    return getNodeInSelection(node => isTargetNode(node));
	  };
	  return ui_lexical_utils.mergeRegister(editor.registerCommand(ui_lexical_core.DRAGSTART_COMMAND, event => {
	    const draggableNode = getDraggableNode();
	    if (!draggableNode) {
	      return false;
	    }
	    const success = handleDragStart(event, draggableNode);
	    if (success) {
	      editor.dispatchCommand(DRAG_START_COMMAND);
	    }
	    return success;
	  }, ui_lexical_core.COMMAND_PRIORITY_HIGH), editor.registerCommand(ui_lexical_core.DRAGOVER_COMMAND, event => {
	    const draggableNode = getDraggableNode();
	    if (!draggableNode) {
	      return false;
	    }
	    return handleDragOver(event, editor);
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), editor.registerCommand(ui_lexical_core.DROP_COMMAND, event => {
	    const draggableNode = getDraggableNode();
	    if (!draggableNode) {
	      return false;
	    }
	    editor.dispatchCommand(DRAG_END_COMMAND);
	    return handleDragDrop(event, editor, draggableNode, onDrop);
	  }, ui_lexical_core.COMMAND_PRIORITY_HIGH));
	}
	function handleDragStart(event, draggableNode) {
	  const dataTransfer = event.dataTransfer;
	  if (!dataTransfer) {
	    return false;
	  }
	  dataTransfer.setData('text/plain', '_');
	  dataTransfer.setDragImage(TRANSPARENT_IMAGE, 0, 0);
	  dataTransfer.setData(DRAG_DATA_FORMAT, JSON.stringify({
	    data: draggableNode.exportJSON(),
	    type: draggableNode.getType()
	  }));
	  return true;
	}
	function handleDragOver(event, editor) {
	  if (!canDrop(event, editor)) {
	    event.preventDefault();
	  }
	  return true;
	}
	function handleDragDrop(event, editor, draggableNode, onDrop) {
	  var _event$dataTransfer;
	  const dragData = (_event$dataTransfer = event.dataTransfer) == null ? void 0 : _event$dataTransfer.getData(DRAG_DATA_FORMAT);
	  if (!dragData) {
	    return false;
	  }
	  const {
	    type,
	    data
	  } = JSON.parse(dragData);
	  if (type !== draggableNode.getType() || !main_core.Type.isPlainObject(data)) {
	    return false;
	  }
	  event.preventDefault();
	  if (canDrop(event, editor) && main_core.Type.isFunction(onDrop)) {
	    const range = getDragSelection(event);
	    draggableNode.remove();
	    const rangeSelection = ui_lexical_core.$createRangeSelection();
	    if (range !== null && range !== undefined) {
	      rangeSelection.applyDOMRange(range);
	    }
	    ui_lexical_core.$setSelection(rangeSelection);
	    onDrop(data);
	  }
	  return true;
	}
	function canDrop(event, editor) {
	  const target = event.target;
	  const selectors = ['code', '.ui-text-editor__file-image'];
	  const imageClassName = editor.getThemeClass('image');
	  if (main_core.Type.isStringFilled(imageClassName)) {
	    selectors.push(`.${imageClassName}`);
	  }

	  // editor.getBBCodeScheme().isAllowedTag();

	  return target instanceof HTMLElement && target.closest(selectors.join(',')) === null && editor.getEditableContainer().contains(target.parentElement);
	}

	/** @memberof BX.UI.TextEditor.Plugins.File */
	const FileType = {
	  FILE: 'file',
	  IMAGE: 'image',
	  VIDEO: 'video'
	};

	/** @memberof BX.UI.TextEditor.Plugins.File */
	const ADD_FILE_COMMAND = ui_lexical_core.createCommand('ADD_FILE_COMMAND');
	const ADD_FILES_COMMAND = ui_lexical_core.createCommand('ADD_FILES_COMMAND');
	const INSERT_FILE_COMMAND = ui_lexical_core.createCommand('INSERT_FILE_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.File */
	const REMOVE_FILE_COMMAND = ui_lexical_core.createCommand('REMOVE_FILE_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.File */
	const GET_INSERTED_FILES_COMMAND = ui_lexical_core.createCommand('GET_INSERTED_FILES_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.File */
	var _enabled = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("enabled");
	var _mode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("mode");
	var _files = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("files");
	var _registerListeners$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	class FilePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerListeners$2, {
	      value: _registerListeners2$2
	    });
	    Object.defineProperty(this, _enabled, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _mode, {
	      writable: true,
	      value: 'file'
	    });
	    Object.defineProperty(this, _files, {
	      writable: true,
	      value: new Map()
	    });
	    const modeOption = editor.getOption('file.mode');
	    babelHelpers.classPrivateFieldLooseBase(this, _enabled)[_enabled] = ['file', 'disk'].includes(modeOption);
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _enabled)[_enabled]) {
	      return;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _mode)[_mode] = modeOption;
	    const _files2 = editor.getOption('file.files', []);
	    this.addFiles(_files2);
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$2)[_registerListeners$2]();
	    this.cleanUpRegister(registerDraggableNode(this.getEditor(), FileImageNode, data => {
	      this.getEditor().dispatchCommand(INSERT_FILE_COMMAND, data);
	    }), registerDraggableNode(this.getEditor(), FileVideoNode, data => {
	      this.getEditor().dispatchCommand(INSERT_FILE_COMMAND, data);
	    }));
	  }
	  static getName() {
	    return 'File';
	  }
	  static getNodes(editor) {
	    return [FileNode, FileImageNode, FileVideoNode];
	  }
	  importBBCode() {
	    if (!this.isEnabled()) {
	      return null;
	    }
	    return {
	      [this.getMode()]: () => ({
	        conversion: node => {
	          // [DISK FILE ID=n14194]
	          // [DISK FILE ID=14194]

	          // [FILE ID=5b87ba3b-edb1-49df-a840-50d17b6c3e8c.fbbdd477d5ff19d61...a875e731fa89cfd1e1]
	          // [FILE ID=14194]
	          const serverFileId = node.getAttribute('id');
	          const createTextNode = () => {
	            return {
	              node: ui_lexical_core.$createTextNode(node.toString())
	            };
	          };
	          if (!main_core.Type.isStringFilled(serverFileId) || this.getMode() === 'disk' && !/^n?\d+$/i.test(serverFileId) || this.getMode() === 'file' && !/^(\d+|[\da-f-]{36}\.[\da-f]{32,})$/i.test(serverFileId)) {
	            return createTextNode();
	          }
	          const info = this.getFile(serverFileId);
	          if (info === null) {
	            return createTextNode();
	          }
	          const fileType = this.getFileType(info);
	          if (fileType === FileType.IMAGE) {
	            const width = main_core.Text.toInteger(node.getAttribute('width'));
	            const height = main_core.Text.toInteger(node.getAttribute('height'));
	            return {
	              node: $createFileImageNode(serverFileId, info, width, height)
	            };
	          }
	          if (fileType === FileType.VIDEO) {
	            const width = main_core.Text.toInteger(node.getAttribute('width'));
	            const height = main_core.Text.toInteger(node.getAttribute('height'));
	            return {
	              node: $createFileVideoNode(serverFileId, info, width, height)
	            };
	          }
	          return {
	            node: $createFileNode(serverFileId, info)
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    if (!this.isEnabled()) {
	      return null;
	    }
	    return {
	      file: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        const attributes = this.getMode() === 'disk' ? {
	          file: ''
	        } : {};
	        attributes.id = lexicalNode.getServerFileId();
	        return {
	          node: scheme.createElement({
	            name: this.getMode(),
	            attributes,
	            inline: true
	          })
	        };
	      },
	      'file-video': lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        const attributes = this.getMode() === 'disk' ? {
	          file: ''
	        } : {};
	        attributes.id = lexicalNode.getServerFileId();
	        const node = scheme.createElement({
	          name: this.getMode(),
	          attributes,
	          inline: false
	        });
	        node.setAttribute('width', lexicalNode.getWidth());
	        node.setAttribute('height', lexicalNode.getHeight());
	        return {
	          node
	        };
	      },
	      'file-image': lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        const attributes = this.getMode() === 'disk' ? {
	          file: ''
	        } : {};
	        attributes.id = lexicalNode.getServerFileId();
	        const node = scheme.createElement({
	          name: this.getMode(),
	          attributes,
	          inline: true
	        });
	        if (lexicalNode.isResized()) {
	          node.setAttribute('width', lexicalNode.getWidth());
	          node.setAttribute('height', lexicalNode.getHeight());
	        }
	        return {
	          node
	        };
	      }
	    };
	  }
	  validateScheme() {
	    if (!this.isEnabled()) {
	      return null;
	    }
	    return {
	      bbcodeMap: {
	        file: this.getMode(),
	        'file-image': this.getMode(),
	        'file-video': this.getMode()
	      }
	    };
	  }
	  isEnabled() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _enabled)[_enabled];
	  }
	  getMode() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _mode)[_mode];
	  }
	  addFile(file) {
	    if (main_core.Type.isPlainObject(file) && (main_core.Type.isStringFilled(file.serverFileId) || main_core.Type.isNumber(file.serverFileId))) {
	      const serverFileId = file.serverFileId.toString();
	      if (!babelHelpers.classPrivateFieldLooseBase(this, _files)[_files].has(serverFileId)) {
	        babelHelpers.classPrivateFieldLooseBase(this, _files)[_files].set(file.serverFileId.toString(), file);
	      }
	    }
	  }
	  addFiles(files) {
	    if (main_core.Type.isArrayFilled(files)) {
	      files.forEach(file => {
	        this.addFile(file);
	      });
	    }
	  }
	  getFile(serverFileId) {
	    if (main_core.Type.isStringFilled(serverFileId) || main_core.Type.isNumber(serverFileId)) {
	      return babelHelpers.classPrivateFieldLooseBase(this, _files)[_files].get(serverFileId.toString()) || null;
	    }
	    return null;
	  }
	  getFileType(file) {
	    if (file != null && file.isImage) {
	      return FileType.IMAGE;
	    }
	    if (file != null && file.isVideo) {
	      return FileType.VIDEO;
	    }
	    return FileType.FILE;
	  }
	  removeFile(serverFileId, skipHistoryStack = true) {
	    if (main_core.Type.isStringFilled(serverFileId) || main_core.Type.isNumber(serverFileId)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _files)[_files].delete(serverFileId.toString());
	      this.getEditor().update(() => {
	        const nodes = [...ui_lexical_core.$nodesOfType(FileNode), ...ui_lexical_core.$nodesOfType(FileImageNode), ...ui_lexical_core.$nodesOfType(FileVideoNode)];
	        nodes.forEach(node => {
	          if (node.getServerFileId().toString() === serverFileId.toString()) {
	            node.remove();
	          }
	        });
	      }, skipHistoryStack ? {
	        tag: 'history-merge'
	      } : {});
	    }
	  }
	}
	function _registerListeners2$2() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_FILE_COMMAND, payload => {
	    if (!main_core.Type.isPlainObject(payload) || !main_core.Type.isPlainObject(payload.info) || !main_core.Type.isNumber(payload.serverFileId) && !main_core.Type.isStringFilled(payload.serverFileId)) {
	      return false;
	    }
	    this.addFile(payload.info);
	    const fileType = this.getFileType(payload.info);
	    let node = null;
	    const previewWidth = payload.info.previewWidth;
	    const previewHeight = payload.info.previewHeight;
	    const renderWidth = payload.width;
	    const renderHeight = payload.height;
	    if (fileType === FileType.IMAGE) {
	      const [width, height] = calcImageSize(previewWidth, previewHeight, renderWidth, renderHeight);
	      node = $createFileImageNode(payload.serverFileId, payload.info, width, height);
	    } else if (fileType === FileType.VIDEO) {
	      let width = 0;
	      let height = 0;
	      if (previewWidth > 0 && previewHeight > 0) {
	        [width, height] = calcImageSize(previewWidth, previewHeight, renderWidth, renderHeight);
	      }
	      node = $createFileVideoNode(payload.serverFileId, payload.info, width, height);
	    } else {
	      node = $createFileNode(payload.serverFileId, payload.info);
	    }

	    // const selection: RangeSelection = $getSelection();
	    // if ($isRangeSelection(selection) && fileType !== FileType.FILE && payload.inline !== true)
	    // {
	    // 	const focus: PointType = selection.focus;
	    // 	const focusNode: TextNode | ElementNode = focus.getNode();
	    // 	if (!selection.isCollapsed())
	    // 	{
	    // 		focusNode.selectEnd();
	    // 	}
	    //
	    // 	const parentNode: ParagraphNode = $findMatchingParent(
	    // 		focusNode,
	    // 		(parent: ElementNode) => $isParagraphNode(parent),
	    // 	);
	    //
	    // 	if (parentNode === null)
	    // 	{
	    // 		$insertNodes([node]);
	    // 		if ($isRootOrShadowRoot(node.getParentOrThrow()))
	    // 		{
	    // 			$wrapNodeInElement(node, $createParagraphNode).selectEnd();
	    // 		}
	    // 	}
	    // 	else if (parentNode.isEmpty())
	    // 	{
	    // 		parentNode.append(node);
	    // 		node.selectEnd();
	    // 	}
	    // 	else
	    // 	{
	    // 		// const paragraph = $createParagraphNode();
	    // 		// paragraph.append(node);
	    // 		// parentNode.insertAfter(paragraph);
	    // 		parentNode.append($createLineBreakNode());
	    // 		parentNode.append(node);
	    // 		node.selectEnd();
	    // 	}
	    // }
	    // else
	    // {
	    // 	$insertNodes([node]);
	    // 	if ($isRootOrShadowRoot(node.getParentOrThrow()))
	    // 	{
	    // 		$wrapNodeInElement(node, $createParagraphNode).selectEnd();
	    // 	}
	    // }

	    ui_lexical_core.$insertNodes([node]);
	    if (ui_lexical_core.$isRootOrShadowRoot(node.getParentOrThrow())) {
	      ui_lexical_utils.$wrapNodeInElement(node, ui_lexical_core.$createParagraphNode).selectEnd();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(REMOVE_FILE_COMMAND, payload => {
	    if (!main_core.Type.isPlainObject(payload) || !main_core.Type.isNumber(payload.serverFileId) && !main_core.Type.isStringFilled(payload.serverFileId)) {
	      return false;
	    }
	    this.removeFile(payload.serverFileId, payload.skipHistoryStack);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(GET_INSERTED_FILES_COMMAND, fn => {
	    if (!main_core.Type.isFunction(fn)) {
	      return false;
	    }
	    const nodes = [...ui_lexical_core.$nodesOfType(FileNode), ...ui_lexical_core.$nodesOfType(FileImageNode), ...ui_lexical_core.$nodesOfType(FileVideoNode)];
	    fn(nodes);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(ADD_FILE_COMMAND, file => {
	    this.addFile(file);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(ADD_FILES_COMMAND, files => {
	    this.addFiles(files);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR));
	}



	var File = /*#__PURE__*/Object.freeze({
		FileImageNode: FileImageNode,
		$createFileImageNode: $createFileImageNode,
		$isFileImageNode: $isFileImageNode,
		FileImageComponent: FileImageComponent,
		FileNode: FileNode,
		$createFileNode: $createFileNode,
		$isFileNode: $isFileNode,
		FileVideoNode: FileVideoNode,
		$createFileVideoNode: $createFileVideoNode,
		$isFileVideoNode: $isFileVideoNode,
		FileType: FileType,
		ADD_FILE_COMMAND: ADD_FILE_COMMAND,
		ADD_FILES_COMMAND: ADD_FILES_COMMAND,
		INSERT_FILE_COMMAND: INSERT_FILE_COMMAND,
		REMOVE_FILE_COMMAND: REMOVE_FILE_COMMAND,
		GET_INSERTED_FILES_COMMAND: GET_INSERTED_FILES_COMMAND,
		FilePlugin: FilePlugin
	});

	function validateImageUrl(url) {
	  return /^(http:|https:|ftp:|blob:|\/)/i.test(url);
	}

	let _$5 = t => t,
	  _t$5,
	  _t2$2;
	var _refs$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _figureResizer$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("figureResizer");
	var _maxWidth$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("maxWidth");
	var _render$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("render");
	var _getContainer$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getContainer");
	var _getImageContainer$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getImageContainer");
	var _setDraggable$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("setDraggable");
	var _handleResizeStart$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeStart");
	var _handleResizeEnd$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeEnd");
	class ImageComponent extends DecoratorComponent {
	  constructor(options) {
	    super(options);
	    Object.defineProperty(this, _handleResizeEnd$2, {
	      value: _handleResizeEnd2$2
	    });
	    Object.defineProperty(this, _handleResizeStart$1, {
	      value: _handleResizeStart2$1
	    });
	    Object.defineProperty(this, _setDraggable$2, {
	      value: _setDraggable2$2
	    });
	    Object.defineProperty(this, _getImageContainer$1, {
	      value: _getImageContainer2$1
	    });
	    Object.defineProperty(this, _getContainer$2, {
	      value: _getContainer2$2
	    });
	    Object.defineProperty(this, _render$2, {
	      value: _render2$2
	    });
	    Object.defineProperty(this, _refs$2, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _figureResizer$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _maxWidth$1, {
	      writable: true,
	      value: 'none'
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2] = new FigureResizer({
	      target: this.getImage(),
	      editor: this.getEditor(),
	      originalWidth: this.getOption('width'),
	      originalHeight: this.getOption('height'),
	      maxWidth: this.getMaxWidth(),
	      events: {
	        onResizeStart: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeStart$1)[_handleResizeStart$1].bind(this),
	        onResizeEnd: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeEnd$2)[_handleResizeEnd$2].bind(this)
	      }
	    });
	    this.getNodeSelection().onSelect(selected => {
	      if (selected || babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2].isResizing()) {
	        main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$2)[_getContainer$2](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2].show();
	      } else {
	        main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$2)[_getContainer$2](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2].hide();
	      }
	      const draggable = selected && !babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2].isResizing();
	      babelHelpers.classPrivateFieldLooseBase(this, _setDraggable$2)[_setDraggable$2](draggable);
	    });
	    this.update(this.getOptions());
	    babelHelpers.classPrivateFieldLooseBase(this, _render$2)[_render$2]();
	  }
	  getImage() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$2)[_refs$2].remember('image', () => {
	      var _config$theme, _config$theme$image;
	      const img = document.createElement('img');
	      img.draggable = false;
	      img.src = this.getOption('src');
	      const config = this.getOption('config', {});
	      if (config != null && (_config$theme = config.theme) != null && (_config$theme$image = _config$theme.image) != null && _config$theme$image.img) {
	        img.className = config.theme.image.img;
	      }
	      img.onerror = event => {
	        img.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
	        main_core.Dom.addClass(this.getTarget(), '--error ui-icon-set__scope');
	      };
	      return img;
	    });
	  }
	  getMaxWidth() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _maxWidth$1)[_maxWidth$1];
	  }
	  update(options) {
	    const width = options.width > 0 ? `${options.width}px` : 'inherit';
	    const aspectRatio = options.width > 0 && options.height > 0 ? `${options.width} / ${options.height}` : 'auto';
	    babelHelpers.classPrivateFieldLooseBase(this, _maxWidth$1)[_maxWidth$1] = options.maxWidth;
	    main_core.Dom.style(this.getImage(), {
	      width,
	      height: 'auto',
	      aspectRatio
	    });
	  }
	}
	function _render2$2() {
	  main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$2)[_getContainer$2](), this.getTarget());
	}
	function _getContainer2$2() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$2)[_refs$2].remember('container', () => {
	    const figureResizer = babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$2)[_figureResizer$2].getContainer();
	    return main_core.Tag.render(_t$5 || (_t$5 = _$5`
				<div class="ui-text-editor-image-component">
					${0}
					${0}
				</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _getImageContainer$1)[_getImageContainer$1](), figureResizer);
	  });
	}
	function _getImageContainer2$1() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$2)[_refs$2].remember('image-container', () => {
	    return main_core.Tag.render(_t2$2 || (_t2$2 = _$5`
				<div class="ui-text-editor-image-container">
					${0}
				</div>
			`), this.getImage());
	  });
	}
	function _setDraggable2$2(draggable) {
	  main_core.Dom.attr(babelHelpers.classPrivateFieldLooseBase(this, _getImageContainer$1)[_getImageContainer$1](), {
	    draggable
	  });
	  if (draggable) {
	    main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$2)[_getContainer$2](), '--draggable');
	  } else {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$2)[_getContainer$2](), '--draggable');
	  }
	}
	function _handleResizeStart2$1(event) {
	  babelHelpers.classPrivateFieldLooseBase(this, _setDraggable$2)[_setDraggable$2](false);
	  this.setSelected(true);
	}
	function _handleResizeEnd2$2(event) {
	  this.setSelected(true);
	  this.getEditor().update(() => {
	    const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	    if ($isImageNode(node)) {
	      const {
	        width,
	        height
	      } = event.getData();
	      node.setWidthAndHeight(width, height);
	    }
	  });
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class ImageNode extends ui_lexical_core.DecoratorNode {
	  constructor(src, width, height, maxWidth, key) {
	    super(key);
	    this.__width = 'inherit';
	    this.__height = 'inherit';
	    this.__maxWidth = 'none';
	    if (validateImageUrl(src)) {
	      this.__src = src;
	    } else {
	      this.__src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
	    }
	    if (main_core.Type.isNumber(width)) {
	      this.__width = Math.round(width);
	    }
	    if (main_core.Type.isNumber(height)) {
	      this.__height = Math.round(height);
	    }
	    if (main_core.Type.isNumber(maxWidth)) {
	      this.__maxWidth = Math.round(maxWidth);
	    }
	  }
	  static getType() {
	    return 'image';
	  }
	  static clone(node) {
	    return new ImageNode(node.__src, node.__width, node.__height, node.__maxWidth, node.__key);
	  }
	  static importJSON(serializedNode) {
	    const {
	      width,
	      height,
	      src,
	      maxWidth
	    } = serializedNode;
	    return $createImageNode({
	      src,
	      width,
	      height,
	      maxWidth
	    });
	  }
	  exportDOM() {
	    const element = document.createElement('img');
	    element.setAttribute('src', this.__src);
	    element.setAttribute('width', this.__width.toString());
	    element.setAttribute('height', this.__height.toString());
	    return {
	      element
	    };
	  }
	  static importDOM() {
	    return {
	      img: node => ({
	        conversion: domNode => {
	          if (domNode instanceof HTMLImageElement && validateImageUrl(domNode.src)) {
	            const {
	              src,
	              width,
	              height
	            } = domNode;
	            const imageNode = $createImageNode({
	              src,
	              width,
	              height
	            });
	            return {
	              node: imageNode
	            };
	          }
	          return null;
	        },
	        priority: 0
	      })
	    };
	  }
	  exportJSON() {
	    return {
	      src: this.getSrc(),
	      width: this.getWidth(),
	      height: this.getHeight(),
	      maxWidth: this.getMaxWidth(),
	      type: 'image',
	      version: 1
	    };
	  }
	  setWidthAndHeight(width, height) {
	    const writable = this.getWritable();
	    if (main_core.Type.isNumber(width)) {
	      writable.__width = Math.round(width);
	    } else if (width === 'inherit') {
	      writable.__width = width;
	    }
	    if (main_core.Type.isNumber(height)) {
	      writable.__height = Math.round(height);
	    } else if (height === 'inherit') {
	      writable.__height = height;
	    }
	  }
	  setMaxWidth(maxWidth) {
	    if (main_core.Type.isNumber(maxWidth) || maxWidth === 'none') {
	      const writable = this.getWritable();
	      writable.__maxWidth = main_core.Type.isNumber(maxWidth) ? Math.round(maxWidth) : maxWidth;
	    }
	  }
	  createDOM(config) {
	    var _theme$image;
	    const span = document.createElement('span');
	    const theme = config.theme;
	    const className = theme == null ? void 0 : (_theme$image = theme.image) == null ? void 0 : _theme$image.container;
	    if (className !== undefined) {
	      span.className = className;
	    }
	    return span;
	  }
	  updateDOM() {
	    return false;
	  }
	  getSrc() {
	    return this.__src;
	  }
	  getWidth() {
	    const self = this.getLatest();
	    return self.__width;
	  }
	  getHeight() {
	    const self = this.getLatest();
	    return self.__height;
	  }
	  getMaxWidth() {
	    const self = this.getLatest();
	    return self.__maxWidth;
	  }
	  decorate(editor, config) {
	    return {
	      componentClass: ImageComponent,
	      options: {
	        src: this.getSrc(),
	        width: this.getWidth(),
	        height: this.getHeight(),
	        maxWidth: this.getMaxWidth(),
	        config
	      }
	    };
	  }
	  isInline() {
	    return true;
	  }
	}
	ImageNode.useDecoratorComponent = true;
	function $createImageNode({
	  src,
	  width,
	  height,
	  maxWidth,
	  key
	}) {
	  return ui_lexical_core.$applyNodeReplacement(new ImageNode(src, width, height, maxWidth, key));
	}
	function $isImageNode(node) {
	  return node instanceof ImageNode;
	}

	function $getSelectionPosition(editor, selection, scrollerContainer) {
	  // const range: Range = window.getSelection().getRangeAt(0);
	  const range = createRange(selection, editor);
	  if (range === null) {
	    return null;
	  }
	  const rangeRects = range.getClientRects();
	  const isMultiline = rangeRects.length > 1;
	  const isBackward = selection.isBackward();
	  let rangeRect = isBackward ? rangeRects[0] : rangeRects[rangeRects.length - 1];
	  if (selection.isCollapsed() && (!rangeRect || rangeRect.left === 0 && rangeRect.top === 0)) {
	    let anchorNode = editor.getElementByKey(selection.anchor.key);
	    let anchorOffset = selection.anchor.offset;
	    if (anchorNode === null) {
	      anchorNode = range.startContainer;
	      anchorOffset = range.startOffset;
	    }
	    const targetNode = anchorNode.childNodes[anchorOffset] || anchorNode;
	    const position = targetNode.getBoundingClientRect();
	    rangeRect = new DOMRect(position.left, position.top, 1, position.height);
	  }
	  if (!rangeRect) {
	    return null;
	  }
	  const verticalGap = 10;
	  const isBodyContainer = scrollerContainer === document.body;
	  const scrollLeft = isBodyContainer ? window.pageXOffset : scrollerContainer.scrollLeft;
	  const scrollTop = isBodyContainer ? window.pageYOffset : scrollerContainer.scrollTop;
	  let left = (isBackward ? rangeRect.left : rangeRect.right) + scrollLeft;
	  let top = rangeRect.top + scrollTop;
	  let bottom = rangeRect.bottom + scrollTop + verticalGap;
	  if (!isBodyContainer) {
	    const scrollerRect = scrollerContainer.getBoundingClientRect();
	    top -= scrollerRect.top;
	    left -= scrollerRect.left;
	    bottom -= scrollerRect.top;
	  }
	  return {
	    left,
	    top,
	    bottom,
	    isBackward,
	    isMultiline
	  };
	}
	function createRange(selection, editor) {
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return null;
	  }
	  const range = document.createRange();
	  const anchorNode = selection.anchor.getNode();
	  const focusNode = selection.focus.getNode();
	  const anchorKey = anchorNode.getKey();
	  const focusKey = focusNode.getKey();
	  let anchorDOM = editor.getElementByKey(anchorKey);
	  let focusDOM = editor.getElementByKey(focusKey);
	  let anchorOffset = selection.anchor.offset;
	  let focusOffset = selection.focus.offset;
	  if (ui_lexical_core.$isTextNode(anchorNode)) {
	    anchorDOM = getDOMTextNode(anchorDOM);
	  }
	  if (ui_lexical_core.$isTextNode(focusNode)) {
	    focusDOM = getDOMTextNode(focusDOM);
	  }
	  if (anchorDOM === null || focusDOM === null) {
	    return null;
	  }
	  if (anchorDOM.nodeName === 'BR') {
	    [anchorDOM, anchorOffset] = getDOMIndexWithinParent(anchorDOM);
	  }
	  if (focusDOM.nodeName === 'BR') {
	    [focusDOM, focusOffset] = getDOMIndexWithinParent(focusDOM);
	  }
	  const firstChild = anchorDOM.firstChild;
	  if (anchorDOM === focusDOM && firstChild !== null && firstChild.nodeName === 'BR' && anchorOffset === 0 && focusOffset === 0) {
	    focusOffset = 1;
	  }
	  try {
	    range.setStart(anchorDOM, anchorOffset);
	    range.setEnd(focusDOM, focusOffset);
	  } catch {
	    return null;
	  }
	  if (range.collapsed && (anchorOffset !== focusOffset || anchorKey !== focusKey)) {
	    // Range is backwards, we need to reverse it
	    range.setStart(focusDOM, focusOffset);
	    range.setEnd(anchorDOM, anchorOffset);
	  }
	  return range;
	}
	function getDOMTextNode(element) {
	  let node = element;
	  while (node !== null) {
	    if (node.nodeType === Node.TEXT_NODE) {
	      return node;
	    }
	    node = node.firstChild;
	  }
	  return null;
	}
	function getDOMIndexWithinParent(node) {
	  const parent = node.parentNode;
	  if (parent === null) {
	    throw new Error('Should never happen');
	  }
	  return [parent, [...parent.childNodes].indexOf(node)];
	}

	const lastPositionMap = new WeakMap();
	const editorPadding = 16;
	function $adjustDialogPosition(popup, editor, initPosition) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return false;
	  }

	  // for an embedded popup: document.body -> editor.getScrollerContainer()
	  const selectionPosition = $getSelectionPosition(editor, selection, document.body);
	  if (selectionPosition === null) {
	    return false;
	  }
	  const {
	    top,
	    left,
	    bottom,
	    isBackward
	  } = selectionPosition;
	  const scrollerRect = main_core.Dom.getPosition(editor.getScrollerContainer());
	  const popupRect = main_core.Dom.getPosition(popup.getPopupContainer());
	  const popupWidth = popupRect.width;
	  let offsetLeft = popupWidth / 2;

	  // Try to fit a popup within a scroll area
	  if (left - offsetLeft < scrollerRect.left) {
	    // Left boundary
	    const overflow = scrollerRect.left - (left - offsetLeft);
	    offsetLeft -= overflow + editorPadding;
	  } else if (scrollerRect.right < left + popupWidth - offsetLeft) {
	    // Right boundary
	    offsetLeft += left + popupWidth - offsetLeft - scrollerRect.right + editorPadding;
	  }
	  popup.setOffset({
	    offsetLeft: -offsetLeft
	  });
	  if (bottom < scrollerRect.top || top > scrollerRect.bottom) {
	    // hide our popup
	    main_core.Dom.style(popup.getPopupContainer(), {
	      left: '-9999px',
	      top: '-9999px'
	    });
	  } else {
	    const initialPosition = main_core.Type.isFunction(initPosition) ? initPosition(selectionPosition) : isBackward ? 'top' : 'bottom';
	    const lastPosition = lastPositionMap.get(popup) || null;
	    let position = lastPosition === null ? initialPosition : lastPosition;
	    if (top + popupRect.height > scrollerRect.bottom && scrollerRect.top < top - popupRect.height) {
	      position = 'top';
	    } else if (top - popupRect.height < scrollerRect.top) {
	      position = 'bottom';
	    }
	    lastPositionMap.set(popup, position);
	    popup.setBindElement({
	      left,
	      top,
	      bottom
	    });
	    popup.adjustPosition({
	      position,
	      forceBindPosition: true
	    });
	  }
	  return true;
	}
	function clearDialogPosition(popup) {
	  lastPositionMap.delete(popup);
	}

	// eslint-disable-next-line no-control-regex
	const ATTRIBUTE_WHITESPACES = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
	const SAFE_URL = /^(?:(?:https?|ftps?|mailto):|[^a-z]|[+.a-z-]+(?:[^+.:a-z-]|$))/i;
	function sanitizeUrl(url) {
	  if (!main_core.Type.isStringFilled(url)) {
	    return '';
	  }
	  const normalizedUrl = url.replaceAll(ATTRIBUTE_WHITESPACES, '');
	  return SAFE_URL.test(normalizedUrl) ? normalizedUrl : '';
	}

	let _$6 = t => t,
	  _t$6,
	  _t2$3;
	var _popup = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _imageUrl = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("imageUrl");
	var _targetContainer = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetContainer");
	var _refs$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _handleSaveBtnClick = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleSaveBtnClick");
	var _handleTextBoxKeyDown = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleTextBoxKeyDown");
	var _handleCancelBtnClick = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCancelBtnClick");
	class ImageDialog extends main_core_events.EventEmitter {
	  constructor(options) {
	    super();
	    Object.defineProperty(this, _handleCancelBtnClick, {
	      value: _handleCancelBtnClick2
	    });
	    Object.defineProperty(this, _handleTextBoxKeyDown, {
	      value: _handleTextBoxKeyDown2
	    });
	    Object.defineProperty(this, _handleSaveBtnClick, {
	      value: _handleSaveBtnClick2
	    });
	    Object.defineProperty(this, _popup, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _imageUrl, {
	      writable: true,
	      value: ''
	    });
	    Object.defineProperty(this, _targetContainer, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _refs$3, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    this.setEventNamespace('BX.UI.TextEditor.ImageDialog');
	    const imageDialogOptions = main_core.Type.isPlainObject(options) ? options : {};
	    this.setTargetContainer(imageDialogOptions.targetContainer);
	    this.subscribeFromOptions(imageDialogOptions.events);
	  }
	  show(options = {}) {
	    var _options$target;
	    const target = (_options$target = options.target) != null ? _options$target : undefined;
	    const targetOptions = main_core.Type.isPlainObject(options.targetOptions) ? options.targetOptions : {};
	    if (!main_core.Type.isUndefined(target)) {
	      this.getPopup().setBindElement(target);
	    }
	    this.getPopup().adjustPosition({
	      ...targetOptions,
	      forceBindPosition: true
	    });
	    this.getPopup().show();
	  }
	  hide() {
	    this.getPopup().close();
	  }
	  isShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup)[_popup] !== null && babelHelpers.classPrivateFieldLooseBase(this, _popup)[_popup].isShown();
	  }
	  destroy() {
	    this.getPopup().destroy();
	  }
	  setImageUrl(url) {
	    if (main_core.Type.isString(url)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _imageUrl)[_imageUrl] = sanitizeUrl(url);
	    }
	  }
	  getImageUrl() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _imageUrl)[_imageUrl];
	  }
	  setTargetContainer(container) {
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _targetContainer)[_targetContainer] = container;
	    }
	  }
	  getTargetContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _targetContainer)[_targetContainer];
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup)[_popup] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup)[_popup] = new main_popup.Popup({
	        autoHide: true,
	        cacheable: false,
	        padding: 0,
	        closeByEsc: true,
	        targetContainer: this.getTargetContainer(),
	        content: this.getContainer(),
	        events: {
	          onClose: () => {
	            this.emit('onClose');
	          },
	          onDestroy: () => {
	            this.emit('onDestroy');
	          },
	          onShow: () => {
	            this.emit('onShow');
	          },
	          onAfterShow: () => {
	            this.emit('onAfterShow');
	          }
	        }
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup)[_popup];
	  }
	  getContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$3)[_refs$3].remember('container', () => {
	      return main_core.Tag.render(_t$6 || (_t$6 = _$6`
				<div class="ui-text-editor-image-dialog">
					<div class="ui-text-editor-image-dialog-form">
						<div class="ui-ctl ui-ctl-textbox ui-ctl-s ui-ctl-inline ui-ctl-w100 ui-text-editor-image-dialog-textbox">
							<div class="ui-ctl-tag">${0}</div>
							${0}
						</div>
						<button type="button" 
							class="ui-text-editor-image-dialog-button" 
							onclick="${0}"
							data-testid="image-dialog-save-btn"
						>
							<span class="ui-icon-set --check"></span>
						</button>
						<button 
							type="button" 
							class="ui-text-editor-image-dialog-button"
							onclick="${0}"
							data-testid="image-dialog-cancel-btn"
						>
							<span class="ui-icon-set --cross-60"></span>
						</button>
					</div>
				</div>
			`), main_core.Loc.getMessage('TEXT_EDITOR_IMAGE_URL'), this.getUrlTextBox(), babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick)[_handleSaveBtnClick].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleCancelBtnClick)[_handleCancelBtnClick].bind(this));
	    });
	  }
	  getUrlTextBox() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$3)[_refs$3].remember('url-textbox', () => {
	      return main_core.Tag.render(_t2$3 || (_t2$3 = _$6`
				<input 
					type="text"
					class="ui-ctl-element"
					placeholder="https://example.com/image.jpeg"
					value="${0}"
					onkeydown="${0}"
					data-testid="image-dialog-textbox"
				>
			`), this.getImageUrl(), babelHelpers.classPrivateFieldLooseBase(this, _handleTextBoxKeyDown)[_handleTextBoxKeyDown].bind(this));
	    });
	  }
	}
	function _handleSaveBtnClick2() {
	  const url = this.getUrlTextBox().value.trim();
	  if (url.length > 0) {
	    this.setImageUrl(url);
	    this.emit('onSave');
	  } else {
	    this.getUrlTextBox().focus();
	  }
	}
	function _handleTextBoxKeyDown2(event) {
	  if (event.key === 'Enter') {
	    event.preventDefault();
	    babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick)[_handleSaveBtnClick]();
	  }
	}
	function _handleCancelBtnClick2() {
	  this.emit('onCancel');
	}

	const INSERT_IMAGE_COMMAND = ui_lexical_core.createCommand('INSERT_IMAGE_COMMAND');
	const INSERT_IMAGE_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_IMAGE_DIALOG_COMMAND');
	var _imageDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("imageDialog");
	var _onEditorScroll = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _lastSelection = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastSelection");
	var _registerCommands$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _restoreSelection = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("restoreSelection");
	var _handleDialogDestroy = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDialogDestroy");
	var _handleEditorScroll = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _registerComponents$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class ImagePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$3, {
	      value: _registerComponents2$3
	    });
	    Object.defineProperty(this, _handleEditorScroll, {
	      value: _handleEditorScroll2
	    });
	    Object.defineProperty(this, _handleDialogDestroy, {
	      value: _handleDialogDestroy2
	    });
	    Object.defineProperty(this, _restoreSelection, {
	      value: _restoreSelection2
	    });
	    Object.defineProperty(this, _registerCommands$5, {
	      value: _registerCommands2$5
	    });
	    Object.defineProperty(this, _imageDialog, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll)[_handleEditorScroll].bind(this)
	    });
	    Object.defineProperty(this, _lastSelection, {
	      writable: true,
	      value: null
	    });
	    this.cleanUpRegister(babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$5)[_registerCommands$5](), registerDraggableNode(this.getEditor(), ImageNode, data => {
	      this.getEditor().dispatchCommand(INSERT_IMAGE_COMMAND, data);
	    }));
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$3)[_registerComponents$3]();
	  }
	  static getName() {
	    return 'Image';
	  }
	  static getNodes(editor) {
	    return [ImageNode];
	  }
	  importBBCode() {
	    return {
	      img: () => ({
	        conversion: node => {
	          // [img]{url}[/img]
	          // [img width={width} height={height}]{url}[/img]
	          const src = node.getContent().trim();
	          const width = Number(node.getAttribute('width'));
	          const height = Number(node.getAttribute('height'));
	          if (validateImageUrl(src)) {
	            return {
	              node: $createImageNode({
	                src,
	                width,
	                height
	              })
	            };
	          }
	          return {
	            node: ui_lexical_core.$createTextNode(node.toString())
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      image: lexicalNode => {
	        const attributes = {};
	        const width = lexicalNode.getWidth();
	        const height = lexicalNode.getHeight();
	        if (main_core.Type.isNumber(width) && main_core.Type.isNumber(height)) {
	          attributes.width = width;
	          attributes.height = height;
	        }
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'img',
	            inline: true,
	            attributes
	          }),
	          after: elementNode => {
	            elementNode.setChildren([scheme.createText(lexicalNode.getSrc())]);
	          }
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: ImageNode
	      }],
	      bbcodeMap: {
	        image: 'img'
	      }
	    };
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].destroy();
	    }
	  }
	}
	function _registerCommands2$5() {
	  return ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(INSERT_IMAGE_COMMAND, payload => {
	    if (!validateImageUrl(payload == null ? void 0 : payload.src)) {
	      return false;
	    }
	    const imageNode = $createImageNode(payload);
	    ui_lexical_core.$insertNodes([imageNode]);
	    if (ui_lexical_core.$isRootOrShadowRoot(imageNode.getParentOrThrow())) {
	      ui_lexical_utils.$wrapNodeInElement(imageNode, ui_lexical_core.$createParagraphNode).selectEnd();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(INSERT_IMAGE_DIALOG_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection)[_lastSelection] = selection.clone();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].destroy();
	    }
	    this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND);
	    babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] = new ImageDialog({
	      // for an embedded popup: document.body -> this.getEditor().getScrollerContainer()
	      targetContainer: document.body,
	      events: {
	        onSave: () => {
	          const url = babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].getImageUrl();
	          if (!main_core.Type.isStringFilled(url)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].hide();
	            return;
	          }
	          this.getEditor().dispatchCommand(INSERT_IMAGE_COMMAND, {
	            src: url
	          });
	          babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].hide();
	        },
	        onCancel: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].hide();
	        },
	        onClose: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy)[_handleDialogDestroy]();
	        },
	        onDestroy: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy)[_handleDialogDestroy]();
	        },
	        onShow: () => {
	          if ($adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].getPopup(), this.getEditor())) {
	            main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll)[_onEditorScroll]);
	            this.getEditor().highlightSelection();
	          }
	        },
	        onAfterShow: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].getUrlTextBox().focus();
	        }
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].destroy();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].isShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _restoreSelection2() {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) && babelHelpers.classPrivateFieldLooseBase(this, _lastSelection)[_lastSelection] !== null) {
	    ui_lexical_core.$setSelection(babelHelpers.classPrivateFieldLooseBase(this, _lastSelection)[_lastSelection]);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection)[_lastSelection] = null;
	    return true;
	  }
	  return false;
	}
	function _handleDialogDestroy2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] = null;
	  main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll)[_onEditorScroll]);
	  this.getEditor().resetHighlightSelection();
	  this.getEditor().update(() => {
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection)[_restoreSelection]()) {
	      this.getEditor().focus();
	    }
	  });
	}
	function _handleEditorScroll2() {
	  this.getEditor().update(() => {
	    $adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].getPopup(), this.getEditor());
	  });
	}
	function _registerComponents2$3() {
	  this.getEditor().getComponentRegistry().register('image', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --incert-image"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_IMAGE'));
	    button.disableInsideUnformatted();
	    button.subscribe('onClick', () => {
	      if (babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _imageDialog)[_imageDialog].isShown()) {
	        return;
	      }
	      this.getEditor().focus(() => {
	        this.getEditor().dispatchCommand(INSERT_IMAGE_DIALOG_COMMAND);
	      });
	    });
	    return button;
	  });
	}



	var Image = /*#__PURE__*/Object.freeze({
		ImageNode: ImageNode,
		$createImageNode: $createImageNode,
		$isImageNode: $isImageNode,
		INSERT_IMAGE_COMMAND: INSERT_IMAGE_COMMAND,
		INSERT_IMAGE_DIALOG_COMMAND: INSERT_IMAGE_DIALOG_COMMAND,
		ImagePlugin: ImagePlugin
	});

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class MentionNode extends ui_lexical_core.ElementNode {
	  constructor(entityId, id, key) {
	    super(key);
	    this.__entityId = entityId;
	    this.__id = id;
	  }
	  static getType() {
	    return 'mention';
	  }
	  static clone(node) {
	    return new MentionNode(node.__entityId, node.__id, node.__key);
	  }
	  getId() {
	    const self = this.getLatest();
	    return self.__id;
	  }
	  getEntityId() {
	    const self = this.getLatest();
	    return self.__entityId;
	  }
	  static importJSON(serializedNode) {
	    const node = $createMentionNode(serializedNode.entityId, serializedNode.id);
	    node.setFormat(serializedNode.format);
	    node.setDirection(serializedNode.direction);
	    return node;
	  }
	  static importDOM() {
	    return {
	      span: domNode => {
	        if (!domNode.hasAttribute('data-mention-id')) {
	          return null;
	        }
	        return {
	          conversion: convertMentionElement,
	          priority: 1
	        };
	      },
	      a: domNode => {
	        if (!domNode.hasAttribute('data-mention-id')) {
	          return null;
	        }
	        return {
	          conversion: convertMentionElement,
	          priority: 1
	        };
	      }
	    };
	  }
	  exportDOM() {
	    const element = document.createElement('span');
	    element.setAttribute('data-mention-entity-id', this.__entityId);
	    element.setAttribute('data-mention-id', this.__id.toString());
	    return {
	      element
	    };
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      entityId: this.__entityId,
	      id: this.__id,
	      type: 'mention',
	      version: 1
	    };
	  }
	  createDOM(config, editor) {
	    var _config$theme;
	    const element = document.createElement('span');
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.mention)) {
	      main_core.Dom.addClass(element, config.theme.mention);
	    }
	    return element;
	  }
	  updateDOM(prevNode, anchor, config) {
	    return false;
	  }
	  canInsertTextBefore() {
	    return false;
	  }
	  canInsertTextAfter() {
	    return false;
	  }
	  canBeEmpty() {
	    return false;
	  }
	  isInline() {
	    return true;
	  }
	  insertNewAfter(selection, restoreSelection) {
	    const newElement = ui_lexical_core.$createParagraphNode();
	    const direction = this.getDirection();
	    newElement.setDirection(direction);
	    this.insertAfter(newElement, restoreSelection);
	    return newElement;
	  }
	  extractWithChild(child, selection, destination) {
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    const anchor = selection.anchor;
	    const focus = selection.focus;
	    const anchorNode = anchor.getNode();
	    const focusNode = focus.getNode();
	    const isBackward = selection.isBackward();
	    const selectionLength = isBackward ? anchor.offset - focus.offset : focus.offset - anchor.offset;
	    return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selectionLength;
	  }
	}
	function convertMentionElement(domNode) {
	  const textContent = domNode.textContent;
	  if (textContent !== null) {
	    const {
	      mentionEntityId,
	      mentionId
	    } = domNode.dataset;
	    const node = $createMentionNode(mentionEntityId, mentionId);
	    return {
	      node
	    };
	  }
	  return null;
	}
	function $createMentionNode(entityId, id) {
	  const mentionNode = new MentionNode(entityId, id);
	  return ui_lexical_core.$applyNodeReplacement(mentionNode);
	}
	function $isMentionNode(node) {
	  return node instanceof MentionNode;
	}

	const PUNCTUATION = '\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%\'"~=<>_:;';
	const TRIGGERS = ['@', '+'].join('');

	// Chars we expect to see in a mention (non-space, non-punctuation).
	const VALID_CHARS = `[^${TRIGGERS}${PUNCTUATION}\\s]`;

	// Non-standard series of chars. Each series must be preceded and followed by
	// a valid char.
	const VALID_JOINS = '(?:' + '\\.[ |$]|' // E.g. "r. " in "Mr. Smith"
	+ ' |' // E.g. " " in "Josh Duck"
	+ `[${PUNCTUATION}]|` // E.g. "-' in "Salier-Hellendag"
	+ ')';
	const LENGTH_LIMIT = 25;
	const mentionRegex = new RegExp('(^|\\s|\\()(' + `[${TRIGGERS}]` + `((?:${VALID_CHARS}${VALID_JOINS}){0,${LENGTH_LIMIT}})` + ')$');
	const INSERT_MENTION_COMMAND = ui_lexical_core.createCommand('INSERT_MENTION_COMMAND');
	const INSERT_MENTION_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_MENTION_DIALOG_COMMAND');
	var _dialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("dialog");
	var _lastQueryMatch = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastQueryMatch");
	var _mentionListening = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("mentionListening");
	var _removeKeyboardCommandsLock = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("removeKeyboardCommandsLock");
	var _removeUpdateListener = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("removeUpdateListener");
	var _onEditorScroll$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _lastPosition = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastPosition");
	var _timeoutId = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("timeoutId");
	var _triggerByAtSign = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("triggerByAtSign");
	var _dialogOptions = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("dialogOptions");
	var _entities = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("entities");
	var _registerCommands$6 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerComponents$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _convertMentionElement = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("convertMentionElement");
	var _registerKeyDownListener = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerKeyDownListener");
	var _registerTextContentListener = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerTextContentListener");
	var _unregisterTextContentListener = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("unregisterTextContentListener");
	var _textContentListener = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("textContentListener");
	var _startMentionListening = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("startMentionListening");
	var _stopMentionListening = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("stopMentionListening");
	var _getQueryMatch = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getQueryMatch");
	var _getTextUpToAnchor = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getTextUpToAnchor");
	var _isSelectionOnEntityBoundary = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("isSelectionOnEntityBoundary");
	var _matchMention = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("matchMention");
	var _splitNodeContainingQuery = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("splitNodeContainingQuery");
	var _getFullMatchOffset = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getFullMatchOffset");
	var _openDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("openDialog");
	var _adjustDialogPosition = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("adjustDialogPosition");
	var _handleEditorScroll$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _handleHideOrDestroy = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleHideOrDestroy");
	var _hideDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("hideDialog");
	var _lockKeyboardCommands = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lockKeyboardCommands");
	var _unlockKeyboardCommands = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("unlockKeyboardCommands");
	class MentionPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _unlockKeyboardCommands, {
	      value: _unlockKeyboardCommands2
	    });
	    Object.defineProperty(this, _lockKeyboardCommands, {
	      value: _lockKeyboardCommands2
	    });
	    Object.defineProperty(this, _hideDialog, {
	      value: _hideDialog2
	    });
	    Object.defineProperty(this, _handleHideOrDestroy, {
	      value: _handleHideOrDestroy2
	    });
	    Object.defineProperty(this, _handleEditorScroll$1, {
	      value: _handleEditorScroll2$1
	    });
	    Object.defineProperty(this, _adjustDialogPosition, {
	      value: _adjustDialogPosition2
	    });
	    Object.defineProperty(this, _openDialog, {
	      value: _openDialog2
	    });
	    Object.defineProperty(this, _getFullMatchOffset, {
	      value: _getFullMatchOffset2
	    });
	    Object.defineProperty(this, _splitNodeContainingQuery, {
	      value: _splitNodeContainingQuery2
	    });
	    Object.defineProperty(this, _matchMention, {
	      value: _matchMention2
	    });
	    Object.defineProperty(this, _isSelectionOnEntityBoundary, {
	      value: _isSelectionOnEntityBoundary2
	    });
	    Object.defineProperty(this, _getTextUpToAnchor, {
	      value: _getTextUpToAnchor2
	    });
	    Object.defineProperty(this, _getQueryMatch, {
	      value: _getQueryMatch2
	    });
	    Object.defineProperty(this, _stopMentionListening, {
	      value: _stopMentionListening2
	    });
	    Object.defineProperty(this, _startMentionListening, {
	      value: _startMentionListening2
	    });
	    Object.defineProperty(this, _textContentListener, {
	      value: _textContentListener2
	    });
	    Object.defineProperty(this, _unregisterTextContentListener, {
	      value: _unregisterTextContentListener2
	    });
	    Object.defineProperty(this, _registerTextContentListener, {
	      value: _registerTextContentListener2
	    });
	    Object.defineProperty(this, _registerKeyDownListener, {
	      value: _registerKeyDownListener2
	    });
	    Object.defineProperty(this, _convertMentionElement, {
	      value: _convertMentionElement2
	    });
	    Object.defineProperty(this, _registerComponents$4, {
	      value: _registerComponents2$4
	    });
	    Object.defineProperty(this, _registerCommands$6, {
	      value: _registerCommands2$6
	    });
	    Object.defineProperty(this, _dialog, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _lastQueryMatch, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _mentionListening, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _removeKeyboardCommandsLock, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _removeUpdateListener, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll$1, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll$1)[_handleEditorScroll$1].bind(this)
	    });
	    Object.defineProperty(this, _lastPosition, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _timeoutId, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _triggerByAtSign, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _dialogOptions, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _entities, {
	      writable: true,
	      value: new Set()
	    });
	    const entities = editor.getOption('mention.entities', []);
	    babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities] = main_core.Type.isArrayFilled(entities) ? new Set(entities) : new Set();
	    const _dialogOptions2 = editor.getOption('mention.dialogOptions');
	    if (main_core.Type.isPlainObject(_dialogOptions2)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _dialogOptions)[_dialogOptions] = _dialogOptions2;
	      if (main_core.Type.isArrayFilled(babelHelpers.classPrivateFieldLooseBase(this, _dialogOptions)[_dialogOptions].entities)) {
	        for (const entity of babelHelpers.classPrivateFieldLooseBase(this, _dialogOptions)[_dialogOptions].entities) {
	          if (main_core.Type.isPlainObject(entity) && main_core.Type.isStringFilled(entity.id)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities].add(entity.id);
	          }
	        }
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _registerKeyDownListener)[_registerKeyDownListener]();
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities].size > 0) {
	      babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$6)[_registerCommands$6]();
	      babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$4)[_registerComponents$4]();
	    }
	  }
	  static getName() {
	    return 'Mention';
	  }
	  static getNodes(editor) {
	    return [MentionNode];
	  }
	  importBBCode() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities].size > 0) {
	      const map = {};
	      for (const entityId of babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities]) {
	        map[entityId] = () => ({
	          conversion: babelHelpers.classPrivateFieldLooseBase(this, _convertMentionElement)[_convertMentionElement],
	          priority: 0
	        });
	      }
	      return map;
	    }
	    return null;
	  }
	  exportBBCode() {
	    return {
	      mention: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: lexicalNode.getEntityId(),
	            value: lexicalNode.getId(),
	            inline: true
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: MentionNode
	      }],
	      bbcodeMap: {
	        mention: '#mention'
	      }
	    };
	  }
	  shouldTriggerByAtSign() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _triggerByAtSign)[_triggerByAtSign];
	  }
	  isDialogVisible() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].isRendered() && babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].getPopup().isShown();
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _timeoutId)[_timeoutId] !== null) {
	      clearTimeout(babelHelpers.classPrivateFieldLooseBase(this, _timeoutId)[_timeoutId]);
	      babelHelpers.classPrivateFieldLooseBase(this, _timeoutId)[_timeoutId] = null;
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].destroy();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _unregisterTextContentListener)[_unregisterTextContentListener]();
	    babelHelpers.classPrivateFieldLooseBase(this, _unlockKeyboardCommands)[_unlockKeyboardCommands]();
	  }
	}
	function _registerCommands2$6() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_MENTION_COMMAND, payload => {
	    if (!main_core.Type.isPlainObject(payload) || !main_core.Type.isStringFilled(payload.entityId) || !main_core.Type.isStringFilled(payload.text) || !main_core.Type.isStringFilled(payload.id) && !main_core.Type.isNumber(payload.id)) {
	      return false;
	    }
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _entities)[_entities].has(payload.entityId)) {
	      console.error(`TextEditor: MentionPlugin: entity id "${payload.entityId}" was not found.`);
	      return false;
	    }
	    const mentionNode = $createMentionNode(payload.entityId, payload.id);
	    mentionNode.append(ui_lexical_core.$createTextNode(payload.text));
	    const nodesToInsert = [];
	    if (main_core.Type.isStringFilled(payload.before)) {
	      nodesToInsert.push(ui_lexical_core.$createTextNode(payload.before));
	    }
	    nodesToInsert.push(mentionNode);
	    if (main_core.Type.isStringFilled(payload.after)) {
	      nodesToInsert.push(ui_lexical_core.$createTextNode(payload.after));
	    }
	    ui_lexical_core.$insertNodes(nodesToInsert);
	    if (ui_lexical_core.$isRootOrShadowRoot(mentionNode.getParentOrThrow())) {
	      ui_lexical_utils.$wrapNodeInElement(mentionNode, ui_lexical_core.$createParagraphNode).selectEnd();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(INSERT_MENTION_DIALOG_COMMAND, payload => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    this.getEditor().update(() => {
	      const currentText = babelHelpers.classPrivateFieldLooseBase(this, _getTextUpToAnchor)[_getTextUpToAnchor](selection);
	      let needSpace = currentText !== null && !/(\s|\()$/.test(currentText);
	      if (needSpace) {
	        const anchor = selection.anchor;
	        const anchorNode = anchor.getNode();
	        if (anchorNode.getIndexWithinParent() === 0 && anchor.offset === 0) {
	          needSpace = false;
	        }
	      }
	      selection.insertText(needSpace ? ' @' : '@');
	    }, {
	      onUpdate: () => {
	        this.getEditor().update(() => {
	          const match = babelHelpers.classPrivateFieldLooseBase(this, _getQueryMatch)[_getQueryMatch](ui_lexical_core.$getSelection());
	          if (match !== null && !babelHelpers.classPrivateFieldLooseBase(this, _isSelectionOnEntityBoundary)[_isSelectionOnEntityBoundary](match.leadOffset)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _openDialog)[_openDialog](match);
	          }
	        });
	      }
	    });
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, payload => {
	    if (!payload || payload.sender !== 'mention') {
	      babelHelpers.classPrivateFieldLooseBase(this, _hideDialog)[_hideDialog]();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return this.isDialogVisible();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerComponents2$4() {
	  this.getEditor().getComponentRegistry().register('mention', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --mention"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_MENTION'));
	    button.disableInsideUnformatted();
	    button.subscribe('onClick', () => {
	      if (this.isDialogVisible()) {
	        return;
	      }
	      this.getEditor().focus(() => {
	        this.getEditor().dispatchCommand(INSERT_MENTION_DIALOG_COMMAND);
	      });
	    });
	    return button;
	  });
	}
	function _convertMentionElement2(node) {
	  return {
	    node: $createMentionNode(node.getName(), node.getValue())
	  };
	}
	function _registerKeyDownListener2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _triggerByAtSign)[_triggerByAtSign] = true;
	  const keyDownListener = event => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _mentionListening)[_mentionListening]) {
	      if (event.key === 'Escape' || event.key === 'Enter') {
	        babelHelpers.classPrivateFieldLooseBase(this, _stopMentionListening)[_stopMentionListening]();
	      }
	    } else if (!babelHelpers.classPrivateFieldLooseBase(this, _mentionListening)[_mentionListening] && (event.key === '+' || event.key === '@')) {
	      babelHelpers.classPrivateFieldLooseBase(this, _timeoutId)[_timeoutId] = setTimeout(() => {
	        this.getEditor().update(() => {
	          const selection = ui_lexical_core.$getSelection();
	          const match = babelHelpers.classPrivateFieldLooseBase(this, _getQueryMatch)[_getQueryMatch](selection);
	          if (match !== null && !babelHelpers.classPrivateFieldLooseBase(this, _isSelectionOnEntityBoundary)[_isSelectionOnEntityBoundary](match.leadOffset)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _openDialog)[_openDialog](match);
	          }
	        });
	      }, 300);
	    }
	    return false;
	  };
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_core.KEY_DOWN_COMMAND, keyDownListener, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerTextContentListener2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _unregisterTextContentListener)[_unregisterTextContentListener]();
	  babelHelpers.classPrivateFieldLooseBase(this, _removeUpdateListener)[_removeUpdateListener] = this.getEditor().registerTextContentListener(babelHelpers.classPrivateFieldLooseBase(this, _textContentListener)[_textContentListener].bind(this));
	}
	function _unregisterTextContentListener2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _removeUpdateListener)[_removeUpdateListener] !== null) {
	    babelHelpers.classPrivateFieldLooseBase(this, _removeUpdateListener)[_removeUpdateListener]();
	    babelHelpers.classPrivateFieldLooseBase(this, _removeUpdateListener)[_removeUpdateListener] = null;
	  }
	}
	function _textContentListener2() {
	  this.getEditor().getEditorState().read(() => {
	    const selection = ui_lexical_core.$getSelection();
	    const match = babelHelpers.classPrivateFieldLooseBase(this, _getQueryMatch)[_getQueryMatch](selection);
	    if (match !== null && !babelHelpers.classPrivateFieldLooseBase(this, _isSelectionOnEntityBoundary)[_isSelectionOnEntityBoundary](match.leadOffset)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _openDialog)[_openDialog](match);
	    } else {
	      babelHelpers.classPrivateFieldLooseBase(this, _hideDialog)[_hideDialog]();
	    }
	  });
	}
	function _startMentionListening2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _mentionListening)[_mentionListening] = true;
	  babelHelpers.classPrivateFieldLooseBase(this, _registerTextContentListener)[_registerTextContentListener]();
	}
	function _stopMentionListening2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _mentionListening)[_mentionListening] = false;
	  babelHelpers.classPrivateFieldLooseBase(this, _unregisterTextContentListener)[_unregisterTextContentListener]();
	}
	function _getQueryMatch2(selection, minMatchLength = 0) {
	  if (!ui_lexical_core.$isRangeSelection(selection) || !selection.isCollapsed()) {
	    return null;
	  }
	  const anchor = selection.anchor;
	  const anchorNode = anchor.getNode();
	  if (!ui_lexical_core.$isTextNode(anchorNode) || !anchorNode.isSimpleText()) {
	    return null;
	  }
	  const text = babelHelpers.classPrivateFieldLooseBase(this, _getTextUpToAnchor)[_getTextUpToAnchor](selection);

	  // console.log("text:", text);

	  if (!main_core.Type.isStringFilled(text)) {
	    return null;
	  }
	  return babelHelpers.classPrivateFieldLooseBase(this, _matchMention)[_matchMention](text, minMatchLength);
	}
	function _getTextUpToAnchor2(selection) {
	  const anchor = selection.anchor;
	  if (anchor.type !== 'text') {
	    return null;
	  }
	  const anchorNode = anchor.getNode();
	  if (!anchorNode.isSimpleText()) {
	    return null;
	  }
	  const anchorOffset = anchor.offset;
	  return anchorNode.getTextContent().slice(0, anchorOffset);
	}
	function _isSelectionOnEntityBoundary2(offset) {
	  if (offset !== 0) {
	    return false;
	  }
	  return this.getEditor().getEditorState().read(() => {
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      const anchor = selection.anchor;
	      const anchorNode = anchor.getNode();
	      const prevSibling = anchorNode.getPreviousSibling();
	      return ui_lexical_core.$isTextNode(prevSibling) && prevSibling.isTextEntity();
	    }
	    return false;
	  });
	}
	function _matchMention2(text, minMatchLength) {
	  const match = mentionRegex.exec(text);
	  if (match !== null) {
	    // The strategy ignores leading whitespace but we need to know it's
	    // length to add it to the leadOffset
	    const maybeLeadingWhitespace = match[1];
	    const matchingString = match[3];
	    if (matchingString.length >= minMatchLength) {
	      return {
	        leadOffset: match.index + maybeLeadingWhitespace.length,
	        matchingString,
	        replaceableString: match[2]
	      };
	    }
	  }
	  return null;
	}
	function _splitNodeContainingQuery2(match) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || !selection.isCollapsed()) {
	    return null;
	  }
	  const anchor = selection.anchor;
	  if (anchor.type !== 'text') {
	    return null;
	  }
	  const anchorNode = anchor.getNode();
	  if (!anchorNode.isSimpleText()) {
	    return null;
	  }
	  const selectionOffset = anchor.offset;
	  const textContent = anchorNode.getTextContent().slice(0, selectionOffset);
	  const characterOffset = match.replaceableString.length;
	  const queryOffset = babelHelpers.classPrivateFieldLooseBase(this, _getFullMatchOffset)[_getFullMatchOffset](textContent, match.matchingString, characterOffset);
	  const startOffset = selectionOffset - queryOffset;
	  if (startOffset < 0) {
	    return null;
	  }
	  let newNode = null;
	  if (startOffset === 0) {
	    [newNode] = anchorNode.splitText(selectionOffset);
	  } else {
	    [, newNode] = anchorNode.splitText(startOffset, selectionOffset);
	  }
	  return newNode;
	}
	function _getFullMatchOffset2(documentText, entryText, offset) {
	  let triggerOffset = offset;
	  for (let i = triggerOffset; i <= entryText.length; i++) {
	    if (documentText.slice(-i) === entryText.slice(0, Math.max(0, i))) {
	      triggerOffset = i;
	    }
	  }
	  return triggerOffset;
	}
	function _openDialog2(queryMatch) {
	  if (this.isDestroyed()) {
	    return;
	  }
	  babelHelpers.classPrivateFieldLooseBase(this, _lastQueryMatch)[_lastQueryMatch] = queryMatch;
	  if (babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog] === null) {
	    const dialogOptions = main_core.Type.isPlainObject(babelHelpers.classPrivateFieldLooseBase(this, _dialogOptions)[_dialogOptions]) ? {
	      ...babelHelpers.classPrivateFieldLooseBase(this, _dialogOptions)[_dialogOptions]
	    } : {};
	    const userEvents = dialogOptions.events;
	    main_core.Runtime.loadExtension('ui.entity-selector').then(exports => {
	      if (this.isDestroyed()) {
	        return;
	      }
	      const {
	        Dialog
	      } = exports;
	      const entitySelectorOptions = {
	        multiple: false,
	        enableSearch: false,
	        clearSearchOnSelect: true,
	        hideOnSelect: true,
	        hideByEsc: true,
	        autoHide: true,
	        height: 300,
	        width: 400,
	        offsetAnimation: false,
	        compactView: true,
	        ...dialogOptions,
	        events: {
	          onShow: () => {
	            babelHelpers.classPrivateFieldLooseBase(this, _lockKeyboardCommands)[_lockKeyboardCommands]();
	            babelHelpers.classPrivateFieldLooseBase(this, _startMentionListening)[_startMentionListening]();
	            main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$1)[_onEditorScroll$1]);
	          },
	          onHide: () => {
	            babelHelpers.classPrivateFieldLooseBase(this, _handleHideOrDestroy)[_handleHideOrDestroy]();
	          },
	          onDestroy: () => {
	            babelHelpers.classPrivateFieldLooseBase(this, _handleHideOrDestroy)[_handleHideOrDestroy]();
	          },
	          'Item:onBeforeSelect': event => {
	            const selectedItem = event.getData().item;
	            event.preventDefault();
	            this.getEditor().update(() => {
	              const nodeToReplace = babelHelpers.classPrivateFieldLooseBase(this, _splitNodeContainingQuery)[_splitNodeContainingQuery](babelHelpers.classPrivateFieldLooseBase(this, _lastQueryMatch)[_lastQueryMatch]);
	              const mentionNode = $createMentionNode(selectedItem.getEntityId(), selectedItem.getId());
	              mentionNode.append(ui_lexical_core.$createTextNode(selectedItem.getTitle()));
	              if (nodeToReplace) {
	                nodeToReplace.replace(mentionNode);
	                mentionNode.select();
	              }
	              babelHelpers.classPrivateFieldLooseBase(this, _hideDialog)[_hideDialog]();
	            });
	          }
	        }
	      };
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog] = new Dialog(entitySelectorOptions);
	      this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND, {
	        sender: 'mention'
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].subscribeFromOptions(userEvents);
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].show();
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].search(queryMatch.matchingString);
	      babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition)[_adjustDialogPosition]();
	    }).catch(error => {
	      console.error('TextEditor: MentionPlugin: cannot load "ui.entity-selector"', error);
	    });
	  } else {
	    this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND, {
	      sender: 'mention'
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].show();
	    babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].search(queryMatch.matchingString);
	    babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition)[_adjustDialogPosition]();
	  }
	}
	function _adjustDialogPosition2() {
	  this.getEditor().update(() => {
	    const selectionPosition = $getSelectionPosition(this.getEditor(), ui_lexical_core.$getSelection(), document.body);
	    if (selectionPosition === null) {
	      return;
	    }
	    const {
	      top,
	      left,
	      bottom
	    } = selectionPosition;
	    const scrollerRect = main_core.Dom.getPosition(this.getEditor().getScrollerContainer());
	    const popupWidth = 400;
	    let offsetLeft = 10;
	    if (left - offsetLeft < scrollerRect.left) {
	      // Left boundary
	      const overflow = scrollerRect.left - (left - offsetLeft);
	      offsetLeft -= overflow + 16;
	    } else if (scrollerRect.right < left + popupWidth - offsetLeft) {
	      // Right boundary
	      offsetLeft += left + popupWidth - offsetLeft - scrollerRect.right + 16;
	    }
	    if (bottom < scrollerRect.top || top > scrollerRect.bottom) {
	      main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].getPopup().getPopupContainer(), 'ui-text-editor-mention-popup__hidden');
	    } else {
	      main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].getPopup().getPopupContainer(), 'ui-text-editor-mention-popup__hidden');
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].show();
	      if (babelHelpers.classPrivateFieldLooseBase(this, _lastPosition)[_lastPosition] === null || babelHelpers.classPrivateFieldLooseBase(this, _lastPosition)[_lastPosition].top !== bottom) {
	        babelHelpers.classPrivateFieldLooseBase(this, _lastPosition)[_lastPosition] = {
	          left: left - offsetLeft,
	          top: bottom
	        };
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].getPopup().setBindElement(babelHelpers.classPrivateFieldLooseBase(this, _lastPosition)[_lastPosition]);
	      babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].getPopup().adjustPosition({
	        forceBindPosition: true,
	        forceTop: true
	      });
	    }
	  });
	}
	function _handleEditorScroll2$1() {
	  babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition)[_adjustDialogPosition]();
	}
	function _handleHideOrDestroy2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _lastPosition)[_lastPosition] = null;
	  babelHelpers.classPrivateFieldLooseBase(this, _unlockKeyboardCommands)[_unlockKeyboardCommands]();
	  babelHelpers.classPrivateFieldLooseBase(this, _stopMentionListening)[_stopMentionListening]();
	  main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$1)[_onEditorScroll$1]);
	}
	function _hideDialog2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog] !== null) {
	    babelHelpers.classPrivateFieldLooseBase(this, _dialog)[_dialog].hide();
	  }
	}
	function _lockKeyboardCommands2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _removeKeyboardCommandsLock)[_removeKeyboardCommandsLock] === null) {
	    babelHelpers.classPrivateFieldLooseBase(this, _removeKeyboardCommandsLock)[_removeKeyboardCommandsLock] = ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_DOWN_COMMAND, () => true, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ARROW_UP_COMMAND, () => true, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ESCAPE_COMMAND, () => true, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_TAB_COMMAND, () => true, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.KEY_ENTER_COMMAND, () => true, ui_lexical_core.COMMAND_PRIORITY_LOW));
	  }
	}
	function _unlockKeyboardCommands2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _removeKeyboardCommandsLock)[_removeKeyboardCommandsLock] !== null) {
	    babelHelpers.classPrivateFieldLooseBase(this, _removeKeyboardCommandsLock)[_removeKeyboardCommandsLock]();
	    babelHelpers.classPrivateFieldLooseBase(this, _removeKeyboardCommandsLock)[_removeKeyboardCommandsLock] = null;
	  }
	}



	var Mention = /*#__PURE__*/Object.freeze({
		INSERT_MENTION_COMMAND: INSERT_MENTION_COMMAND,
		INSERT_MENTION_DIALOG_COMMAND: INSERT_MENTION_DIALOG_COMMAND,
		MentionPlugin: MentionPlugin,
		MentionNode: MentionNode,
		$createMentionNode: $createMentionNode,
		$isMentionNode: $isMentionNode
	});

	/* eslint-disable no-underscore-dangle,@bitrix24/bitrix24-rules/no-pseudo-private */
	class SmileyNode extends ui_lexical_core.DecoratorNode {
	  static getType() {
	    return 'smiley';
	  }
	  static clone(node) {
	    return new SmileyNode(node.__src, node.__typing, node.__width, node.__height, node.__key);
	  }
	  constructor(src, typing, width, height, key) {
	    super(key);
	    this.__width = null;
	    this.__height = null;
	    this.__src = src;
	    this.__typing = typing;
	    if (main_core.Type.isNumber(width)) {
	      this.__width = width;
	    }
	    if (main_core.Type.isNumber(height)) {
	      this.__height = height;
	    }
	  }
	  getSrc() {
	    return this.__src;
	  }
	  getTyping() {
	    return this.__typing;
	  }
	  getWidth() {
	    return this.__width;
	  }
	  getHeight() {
	    return this.__height;
	  }
	  createDOM(config) {
	    var _config$theme;
	    const img = document.createElement('img');
	    img.src = encodeURI(this.__src);
	    if (this.getWidth() > 0 && this.getHeight() > 0) {
	      main_core.Dom.style(img, {
	        width: `${this.getWidth()}px`,
	        height: `${this.getHeight()}px`
	      });
	    }
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.smiley)) {
	      main_core.Dom.addClass(img, config.theme.smiley);
	    }
	    main_core.Dom.attr(img, {
	      draggable: false
	    });
	    return img;
	  }
	  updateDOM(prevNode, dom, config) {
	    return false;
	  }
	  static importJSON(serializedNode) {
	    const {
	      src,
	      typing,
	      width,
	      height
	    } = serializedNode;
	    return $createSmileyNode(src, typing, width, height);
	  }
	  exportDOM() {
	    const span = document.createElement('span');
	    span.textContent = this.getTyping();
	    return {
	      element: span
	    };
	  }
	  exportJSON() {
	    return {
	      src: this.getSrc(),
	      typing: this.getTyping(),
	      width: this.getWidth(),
	      height: this.getHeight(),
	      type: 'smiley',
	      version: 1
	    };
	  }
	  decorate(editor, config) {
	    return {};
	  }
	  getTextContent() {
	    return this.getTyping();
	  }
	  isInline() {
	    return true;
	  }
	  isKeyboardSelectable() {
	    return false;
	  }
	  isIsolated() {
	    return false;
	  }
	}
	function $isSmileyNode(node) {
	  return node instanceof SmileyNode;
	}
	function $createSmileyNode(src, typing, width, height) {
	  const node = new SmileyNode(src, typing, width, height);
	  // node.setMode('token');
	  // node.setDetail('unmergeable');

	  return ui_lexical_core.$applyNodeReplacement(node);
	}

	var _popup$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _targetNode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetNode");
	class SmileyDialog extends main_core_events.EventEmitter {
	  constructor(dialogOptions) {
	    super();
	    Object.defineProperty(this, _popup$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _targetNode, {
	      writable: true,
	      value: null
	    });
	    this.setEventNamespace('BX.UI.TextEditor.SmileyDialog');
	    const options = main_core.Type.isPlainObject(dialogOptions) ? dialogOptions : {};
	    this.setTargetNode(options.targetNode);
	    this.subscribeFromOptions(options.events);
	  }
	  show() {
	    this.getPopup().adjustPosition({
	      forceBindPosition: true
	    });
	    this.getPopup().show();
	  }
	  hide() {
	    this.getPopup().close();
	  }
	  isShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1] !== null && babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1].isShown();
	  }
	  destroy() {
	    this.getPopup().destroy();
	  }
	  setTargetNode(container) {
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _targetNode)[_targetNode] = container;
	    }
	  }
	  getTargetNode() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _targetNode)[_targetNode];
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1] === null) {
	      const popupWidth = 360;
	      const targetNode = this.getTargetNode();
	      const rect = targetNode.getBoundingClientRect();
	      const targetNodeWidth = rect.width;
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1] = new main_popup.Popup({
	        autoHide: true,
	        padding: 0,
	        closeByEsc: true,
	        width: popupWidth,
	        height: 250,
	        bindElement: this.getTargetNode(),
	        events: {
	          onClose: () => {
	            this.emit('onClose');
	          },
	          onDestroy: () => {
	            this.emit('onDestroy');
	          },
	          onFirstShow: () => {
	            const dialog = this;
	            main_core.Runtime.loadExtension('ui.vue3', 'ui.vue3.components.smiles').then(exports => {
	              const {
	                BitrixVue,
	                Smiles
	              } = exports;
	              const app = BitrixVue.createApp({
	                methods: {
	                  handleSelect(text) {
	                    dialog.emit('onSelect', {
	                      smiley: text.trim()
	                    });
	                  }
	                },
	                components: {
	                  Smiles
	                },
	                template: '<Smiles @selectSmile="handleSelect($event.text)"/>'
	              });
	              app.mount(babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1].getContentContainer());
	            }).catch(() => {
	              babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1].close();
	            });
	          },
	          onShow: event => {
	            const popup = event.getTarget();
	            const offsetLeft = targetNodeWidth / 2 - popupWidth / 2;
	            const angleShift = main_popup.Popup.getOption('angleLeftOffset') - main_popup.Popup.getOption('angleMinTop');
	            popup.setAngle({
	              offset: popupWidth / 2 - angleShift
	            });
	            popup.setOffset({
	              offsetLeft: offsetLeft + main_popup.Popup.getOption('angleLeftOffset')
	            });
	          }
	        }
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$1)[_popup$1];
	  }
	}

	/* eslint-disable no-underscore-dangle */
	const INSERT_SMILEY_COMMAND = ui_lexical_core.createCommand('INSERT_SMILEY_COMMAND');
	const INSERT_SMILEY_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_SMILEY_DIALOG_COMMAND');
	var _smileyParser = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("smileyParser");
	var _smileyDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("smileyDialog");
	var _registerListeners$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _registerInsertSmileyCommand = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerInsertSmileyCommand");
	var _registerComponents$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class SmileyPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$5, {
	      value: _registerComponents2$5
	    });
	    Object.defineProperty(this, _registerInsertSmileyCommand, {
	      value: _registerInsertSmileyCommand2
	    });
	    Object.defineProperty(this, _registerListeners$3, {
	      value: _registerListeners2$3
	    });
	    Object.defineProperty(this, _smileyParser, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _smileyDialog, {
	      writable: true,
	      value: null
	    });
	    if (ui_smiley.SmileyManager.getSize() > 0) {
	      babelHelpers.classPrivateFieldLooseBase(this, _smileyParser)[_smileyParser] = new ui_smiley.SmileyParser(ui_smiley.SmileyManager.getAll());
	      babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$3)[_registerListeners$3]();
	      babelHelpers.classPrivateFieldLooseBase(this, _registerInsertSmileyCommand)[_registerInsertSmileyCommand]();
	      babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$5)[_registerComponents$5]();
	    }
	  }
	  static getName() {
	    return 'Smiley';
	  }
	  static getNodes(editor) {
	    return [SmileyNode];
	  }
	  importBBCode() {
	    return null;
	  }
	  exportBBCode() {
	    return {
	      smiley: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createText(lexicalNode.getTyping())
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      bbcodeMap: {
	        smiley: '#text'
	      }
	    };
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].destroy();
	    }
	  }
	}
	function _registerListeners2$3() {
	  const handledTextNodes = new Set();
	  this.cleanUpRegister(this.getEditor().registerNodeTransform(ui_lexical_core.TextNode, node => {
	    if (!node.isSimpleText() || handledTextNodes.has(node.getKey())) {
	      return;
	    }
	    const $isUnformatted = ui_lexical_utils.$findMatchingParent(node, parentNode => {
	      return (parentNode.__flags & UNFORMATTED) !== 0;
	    });
	    if ($isUnformatted) {
	      return;
	    }
	    const splits = babelHelpers.classPrivateFieldLooseBase(this, _smileyParser)[_smileyParser].parse(node.getTextContent());
	    if (splits.length > 0) {
	      const splitOffsets = splits.reduce((acc, smiley) => {
	        acc.push(smiley.start, smiley.end);
	        return acc;
	      }, []);
	      const textNodes = node.splitText(...splitOffsets);
	      // console.log("textNodes", splitOffsets, textNodes);

	      for (const textNode of textNodes) {
	        const smiley = ui_smiley.SmileyManager.get(textNode.getTextContent()) || null;
	        if (smiley) {
	          // console.log('replace');
	          const smileyNode = $createSmileyNode(smiley.getImage(), smiley.getTyping(), smiley.getWidth(), smiley.getHeight());
	          textNode.replace(smileyNode);
	          // smileyNode.selectNext(0, 0);
	        } else {
	          handledTextNodes.add(textNode.getKey());
	        }
	      }
	    }
	  }), this.getEditor().registerUpdateListener(() => {
	    handledTextNodes.clear();
	  }),
	  // Workaround for a disappearing cursor in FireFox and Safari.
	  // Lexical always sets contentEditable = 'false' for all decorator nodes.
	  this.getEditor().registerMutationListener(SmileyNode, nodeMutations => {
	    for (const [nodeKey, mutation] of nodeMutations) {
	      if (mutation === 'created') {
	        const dom = this.getEditor().getElementByKey(nodeKey);
	        dom.contentEditable = true;
	      }
	    }
	  }), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].hide();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].isShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerInsertSmileyCommand2() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_SMILEY_COMMAND, payload => {
	    const smiley = ui_smiley.SmileyManager.get(payload) || null;
	    if (!smiley) {
	      return false;
	    }
	    const smileyNode = $createSmileyNode(smiley.getImage(), smiley.getTyping(), smiley.getWidth(), smiley.getHeight());
	    ui_lexical_core.$insertNodes([ui_lexical_core.$createTextNode(' '), smileyNode, ui_lexical_core.$createTextNode(' ')]);
	    if (ui_lexical_core.$isRootOrShadowRoot(smileyNode.getParentOrThrow())) {
	      ui_lexical_utils.$wrapNodeInElement(smileyNode, ui_lexical_core.$createParagraphNode).selectEnd();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(INSERT_SMILEY_DIALOG_COMMAND, payload => {
	    if (!main_core.Type.isPlainObject(payload) || !main_core.Type.isElementNode(payload.targetNode)) {
	      return false;
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] !== null) {
	      if (babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].getTargetNode() === payload.targetNode) {
	        babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].show();
	        return true;
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].destroy();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] = new SmileyDialog({
	      targetNode: payload.targetNode,
	      events: {
	        onSelect: event => {
	          this.getEditor().dispatchCommand(INSERT_SMILEY_COMMAND, event.getData().smiley);
	          babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].hide();
	        },
	        onDestroy: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog] = null;
	        }
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _smileyDialog)[_smileyDialog].show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerComponents2$5() {
	  this.getEditor().getComponentRegistry().register('smileys', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --insert-emoji"></span>');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_SMILEYS'));
	    button.subscribe('onClick', () => {
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(INSERT_SMILEY_DIALOG_COMMAND, {
	          targetNode: button.getContainer()
	        });
	      });
	    });
	    return button;
	  });
	}



	var Smiley = /*#__PURE__*/Object.freeze({
		INSERT_SMILEY_COMMAND: INSERT_SMILEY_COMMAND,
		INSERT_SMILEY_DIALOG_COMMAND: INSERT_SMILEY_DIALOG_COMMAND,
		SmileyPlugin: SmileyPlugin,
		SmileyNode: SmileyNode,
		$isSmileyNode: $isSmileyNode,
		$createSmileyNode: $createSmileyNode,
		SmileyDialog: SmileyDialog
	});

	let _$7 = t => t,
	  _t$7,
	  _t2$4;
	var _refs$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _figureResizer$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("figureResizer");
	var _trusted = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("trusted");
	var _render$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("render");
	var _getContainer$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getContainer");
	var _getVideo$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getVideo");
	var _handleResize$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResize");
	var _handleResizeEnd$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResizeEnd");
	class VideoComponent extends DecoratorComponent {
	  constructor(options) {
	    super(options);
	    Object.defineProperty(this, _handleResizeEnd$3, {
	      value: _handleResizeEnd2$3
	    });
	    Object.defineProperty(this, _handleResize$1, {
	      value: _handleResize2$1
	    });
	    Object.defineProperty(this, _getVideo$1, {
	      value: _getVideo2$1
	    });
	    Object.defineProperty(this, _getContainer$3, {
	      value: _getContainer2$3
	    });
	    Object.defineProperty(this, _render$3, {
	      value: _render2$3
	    });
	    Object.defineProperty(this, _refs$4, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _figureResizer$3, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _trusted, {
	      writable: true,
	      value: false
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _trusted)[_trusted] = main_core.Type.isStringFilled(this.getOption('provider'));
	    babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$3)[_figureResizer$3] = new FigureResizer({
	      target: babelHelpers.classPrivateFieldLooseBase(this, _getVideo$1)[_getVideo$1](),
	      editor: this.getEditor(),
	      minWidth: 120,
	      minHeight: 120,
	      freeTransform: true,
	      events: {
	        onResize: babelHelpers.classPrivateFieldLooseBase(this, _handleResize$1)[_handleResize$1].bind(this),
	        onResizeEnd: babelHelpers.classPrivateFieldLooseBase(this, _handleResizeEnd$3)[_handleResizeEnd$3].bind(this)
	      }
	    });
	    this.getNodeSelection().onSelect(selected => {
	      if (selected || babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$3)[_figureResizer$3].isResizing()) {
	        main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$3)[_getContainer$3](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$3)[_figureResizer$3].show();
	      } else {
	        main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$3)[_getContainer$3](), '--selected');
	        babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$3)[_figureResizer$3].hide();
	      }
	    });
	    this.update(this.getOptions());
	    babelHelpers.classPrivateFieldLooseBase(this, _render$3)[_render$3]();
	  }
	  update(options) {
	    const width = main_core.Type.isNumber(options.width) && options.width > 0 ? options.width : null;
	    const height = main_core.Type.isNumber(options.height) && options.height > 0 ? options.height : null;
	    const aspectRatio = width > 0 && height > 0 ? `${width} / ${height}` : 'auto';
	    main_core.Dom.adjust(babelHelpers.classPrivateFieldLooseBase(this, _getVideo$1)[_getVideo$1](), {
	      attrs: {
	        width
	      },
	      style: {
	        width,
	        height: 'auto',
	        aspectRatio
	      }
	    });
	  }
	}
	function _render2$3() {
	  main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _getContainer$3)[_getContainer$3](), this.getTarget());
	}
	function _getContainer2$3() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$4)[_refs$4].remember('container', () => {
	    return main_core.Tag.render(_t$7 || (_t$7 = _$7`
				<div class="ui-text-editor-video-component">
					<div class="ui-text-editor-video-object-container">${0}</div>
					${0}
				</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _getVideo$1)[_getVideo$1](), babelHelpers.classPrivateFieldLooseBase(this, _figureResizer$3)[_figureResizer$3].getContainer());
	  });
	}
	function _getVideo2$1() {
	  return babelHelpers.classPrivateFieldLooseBase(this, _refs$4)[_refs$4].remember('video', () => {
	    var _config$theme, _config$theme$video;
	    let video = null;
	    const src = this.getOption('src');
	    if (babelHelpers.classPrivateFieldLooseBase(this, _trusted)[_trusted]) {
	      video = main_core.Tag.render(_t2$4 || (_t2$4 = _$7`<iframe frameborder="0" src="about:blank" draggable="false"></iframe>`));
	      video.src = src;
	    } else {
	      video = main_core.Dom.create({
	        tag: 'video',
	        attrs: {
	          controls: true,
	          preload: 'metadata',
	          playsinline: true,
	          src
	        },
	        events: {
	          loadedmetadata: event => {
	            this.getEditor().update(() => {
	              const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	              if ($isVideoNode(node) && node.getWidth() === 0) {
	                const [width, height] = calcImageSize(event.target.videoWidth, event.target.videoHeight, 600, 600);
	                node.setWidthAndHeight(width, height);
	              }
	            });
	          }
	        }
	      });
	    }
	    const config = this.getOption('config', {});
	    if (config != null && (_config$theme = config.theme) != null && (_config$theme$video = _config$theme.video) != null && _config$theme$video.object) {
	      video.className = config.theme.video.object;
	    }
	    return video;
	  });
	}
	function _handleResize2$1(event) {
	  this.update(event.getData());
	}
	function _handleResizeEnd2$3(event) {
	  this.setSelected(true);
	  this.getEditor().update(() => {
	    const node = ui_lexical_core.$getNodeByKey(this.getNodeKey());
	    if ($isVideoNode(node)) {
	      const {
	        width,
	        height
	      } = event.getData();
	      node.setWidthAndHeight(width, height);
	    }
	  });
	}

	/* eslint-disable no-underscore-dangle, @bitrix24/bitrix24-rules/no-pseudo-private */
	class VideoNode extends ui_lexical_core.DecoratorNode {
	  constructor(src, width, height, key) {
	    super(key);
	    this.__width = 560;
	    this.__height = 315;
	    this.__provider = null;
	    this.__src = src;
	    if (main_core.Type.isNumber(width)) {
	      this.__width = Math.round(width);
	    }
	    if (main_core.Type.isNumber(height)) {
	      this.__height = Math.round(height);
	    }
	    const url = /^https?:/.test(src) ? src : `https://${src.replace(/^\/\//, '')}`;
	    const uri = new main_core.Uri(url);
	    const videoService = ui_videoService.VideoService.createByHost(uri.getHost());
	    if (videoService) {
	      this.__provider = videoService.getId();
	    }
	  }
	  static getType() {
	    return 'video';
	  }
	  static clone(node) {
	    return new VideoNode(node.__src, node.__width, node.__height, node.__key);
	  }
	  static importJSON(serializedNode) {
	    const {
	      width,
	      height,
	      src
	    } = serializedNode;
	    return $createVideoNode({
	      src,
	      width,
	      height
	    });
	  }
	  exportDOM() {
	    return {
	      element: null
	    };
	  }
	  static importDOM() {
	    return null;
	  }
	  exportJSON() {
	    return {
	      src: this.getSrc(),
	      width: this.getWidth(),
	      height: this.getHeight(),
	      type: 'video',
	      version: 1
	    };
	  }
	  setWidthAndHeight(width, height) {
	    const writable = this.getWritable();
	    if (main_core.Type.isNumber(width)) {
	      writable.__width = Math.round(width);
	    }
	    if (main_core.Type.isNumber(height)) {
	      writable.__height = Math.round(height);
	    }
	  }
	  createDOM(config) {
	    var _theme$video;
	    const span = document.createElement('span');
	    const theme = config.theme;
	    const className = theme == null ? void 0 : (_theme$video = theme.video) == null ? void 0 : _theme$video.container;
	    if (className !== undefined) {
	      span.className = className;
	    }
	    return span;
	  }
	  updateDOM() {
	    return false;
	  }
	  getSrc() {
	    return this.__src;
	  }
	  getWidth() {
	    const self = this.getLatest();
	    return self.__width;
	  }
	  getHeight() {
	    const self = this.getLatest();
	    return self.__height;
	  }
	  getProvider() {
	    const self = this.getLatest();
	    return self.__provider;
	  }
	  decorate(editor, config) {
	    return {
	      componentClass: VideoComponent,
	      options: {
	        src: this.getSrc(),
	        width: this.getWidth(),
	        height: this.getHeight(),
	        provider: this.getProvider(),
	        config
	      }
	    };
	  }
	  isInline() {
	    return true;
	  }
	}
	VideoNode.useDecoratorComponent = true;
	function $createVideoNode({
	  src,
	  width,
	  height,
	  key
	}) {
	  return ui_lexical_core.$applyNodeReplacement(new VideoNode(src, width, height, key));
	}
	function $isVideoNode(node) {
	  return node instanceof VideoNode;
	}

	let _$8 = t => t,
	  _t$8,
	  _t2$5,
	  _t3;
	var _popup$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _videoUrl = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("videoUrl");
	var _targetContainer$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetContainer");
	var _refs$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _handleSaveBtnClick$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleSaveBtnClick");
	var _handleTextBoxKeyDown$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleTextBoxKeyDown");
	var _handleTextBoxInput = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleTextBoxInput");
	var _handleCancelBtnClick$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCancelBtnClick");
	class VideoDialog extends main_core_events.EventEmitter {
	  constructor(options) {
	    super();
	    Object.defineProperty(this, _handleCancelBtnClick$1, {
	      value: _handleCancelBtnClick2$1
	    });
	    Object.defineProperty(this, _handleTextBoxInput, {
	      value: _handleTextBoxInput2
	    });
	    Object.defineProperty(this, _handleTextBoxKeyDown$1, {
	      value: _handleTextBoxKeyDown2$1
	    });
	    Object.defineProperty(this, _handleSaveBtnClick$1, {
	      value: _handleSaveBtnClick2$1
	    });
	    Object.defineProperty(this, _popup$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _videoUrl, {
	      writable: true,
	      value: ''
	    });
	    Object.defineProperty(this, _targetContainer$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _refs$5, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    this.setEventNamespace('BX.UI.TextEditor.VideoDialog');
	    const videoDialogOptions = main_core.Type.isPlainObject(options) ? options : {};
	    this.setTargetContainer(videoDialogOptions.targetContainer);
	    this.subscribeFromOptions(videoDialogOptions.events);
	  }
	  show(options = {}) {
	    var _options$target;
	    const target = (_options$target = options.target) != null ? _options$target : undefined;
	    const targetOptions = main_core.Type.isPlainObject(options.targetOptions) ? options.targetOptions : {};
	    if (!main_core.Type.isUndefined(target)) {
	      this.getPopup().setBindElement(target);
	    }
	    this.getPopup().adjustPosition({
	      ...targetOptions,
	      forceBindPosition: true
	    });
	    this.getPopup().show();
	  }
	  hide() {
	    this.getPopup().close();
	  }
	  isShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$2)[_popup$2] !== null && babelHelpers.classPrivateFieldLooseBase(this, _popup$2)[_popup$2].isShown();
	  }
	  destroy() {
	    this.getPopup().destroy();
	  }
	  setVideoUrl(url) {
	    if (main_core.Type.isString(url)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _videoUrl)[_videoUrl] = sanitizeUrl(url);
	    }
	  }
	  getVideoUrl() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _videoUrl)[_videoUrl];
	  }
	  setTargetContainer(container) {
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _targetContainer$1)[_targetContainer$1] = container;
	    }
	  }
	  getTargetContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _targetContainer$1)[_targetContainer$1];
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$2)[_popup$2] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$2)[_popup$2] = new main_popup.Popup({
	        autoHide: true,
	        cacheable: false,
	        padding: 0,
	        closeByEsc: true,
	        targetContainer: this.getTargetContainer(),
	        content: this.getContainer(),
	        events: {
	          onShow: () => {
	            this.emit('onShow');
	          },
	          onClose: () => {
	            this.emit('onClose');
	          },
	          onDestroy: () => {
	            this.emit('onDestroy');
	          },
	          onAfterShow: () => {
	            this.getUrlTextBox().focus();
	          }
	        }
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$2)[_popup$2];
	  }
	  getContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$5)[_refs$5].remember('container', () => {
	      return main_core.Tag.render(_t$8 || (_t$8 = _$8`
				<div class="ui-text-editor-video-dialog">
					<div class="ui-text-editor-video-dialog-form">
						<div class="ui-ctl ui-ctl-textbox ui-ctl-s ui-ctl-inline ui-ctl-w100 ui-text-editor-video-dialog-textbox">
							<div class="ui-ctl-tag">${0}</div>
							${0}
						</div>
						<button type="button" 
							class="ui-text-editor-video-dialog-button" 
							onclick="${0}"
							data-testid="video-dialog-save-btn"
						>
							<span class="ui-icon-set --check"></span>
						</button>
						<button 
							type="button" 
							class="ui-text-editor-video-dialog-button"
							onclick="${0}"
							data-testid="video-dialog-cancel-btn"
						>
							<span class="ui-icon-set --cross-60"></span>
						</button>
					</div>
					${0}
				</div>
			`), main_core.Loc.getMessage('TEXT_EDITOR_VIDEO_INSERT_TITLE'), this.getUrlTextBox(), babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick$1)[_handleSaveBtnClick$1].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleCancelBtnClick$1)[_handleCancelBtnClick$1].bind(this), this.getStatusContainer());
	    });
	  }
	  getUrlTextBox() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$5)[_refs$5].remember('url-textbox', () => {
	      return main_core.Tag.render(_t2$5 || (_t2$5 = _$8`
				<input 
					type="text"
					class="ui-ctl-element"
					placeholder="https://"
					value="${0}"
					onkeydown="${0}"
					oninput="${0}"
					data-testid="video-dialog-textbox"
				>
			`), this.getVideoUrl(), babelHelpers.classPrivateFieldLooseBase(this, _handleTextBoxKeyDown$1)[_handleTextBoxKeyDown$1].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleTextBoxInput)[_handleTextBoxInput].bind(this));
	    });
	  }
	  getStatusContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$5)[_refs$5].remember('status', () => {
	      return main_core.Tag.render(_t3 || (_t3 = _$8`
				<div class="ui-text-editor-video-dialog-status">${0}</div>
			`), main_core.Loc.getMessage('TEXT_EDITOR_VIDEO_INSERT_HINT'));
	    });
	  }
	  showError(error) {
	    main_core.Dom.addClass(this.getStatusContainer(), '--error');
	    main_core.Dom.addClass(this.getUrlTextBox().parentNode, 'ui-ctl-warning');
	    if (main_core.Type.isStringFilled(error)) {
	      this.getStatusContainer().textContent = error;
	    }
	  }
	  clearError() {
	    main_core.Dom.removeClass(this.getStatusContainer(), '--error');
	    main_core.Dom.removeClass(this.getUrlTextBox().parentNode, 'ui-ctl-warning');
	    this.getStatusContainer().textContent = main_core.Loc.getMessage('TEXT_EDITOR_VIDEO_INSERT_HINT');
	  }
	}
	function _handleSaveBtnClick2$1() {
	  const url = this.getUrlTextBox().value.trim();
	  if (url.length > 0) {
	    this.setVideoUrl(url);
	    this.emit('onSave');
	  } else {
	    this.getUrlTextBox().focus();
	  }
	}
	function _handleTextBoxKeyDown2$1(event) {
	  if (event.key === 'Enter') {
	    event.preventDefault();
	    babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick$1)[_handleSaveBtnClick$1]();
	  }
	}
	function _handleTextBoxInput2(event) {
	  this.emit('onInput');
	}
	function _handleCancelBtnClick2$1() {
	  this.emit('onCancel');
	}

	function validateVideoUrl(url) {
	  return /^(http:|https:|\/)/i.test(url);
	}

	/** @memberof BX.UI.TextEditor.Plugins.Video */
	const INSERT_VIDEO_COMMAND = ui_lexical_core.createCommand('INSERT_VIDEO_COMMAND');

	/** @memberof BX.UI.TextEditor.Plugins.Video */
	const INSERT_VIDEO_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_VIDEO_DIALOG_COMMAND');
	var _videoDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("videoDialog");
	var _onEditorScroll$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _lastSelection$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastSelection");
	var _registerCommands$7 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _restoreSelection$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("restoreSelection");
	var _handleDialogDestroy$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDialogDestroy");
	var _handleEditorScroll$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _registerComponents$6 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class VideoPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$6, {
	      value: _registerComponents2$6
	    });
	    Object.defineProperty(this, _handleEditorScroll$2, {
	      value: _handleEditorScroll2$2
	    });
	    Object.defineProperty(this, _handleDialogDestroy$1, {
	      value: _handleDialogDestroy2$1
	    });
	    Object.defineProperty(this, _restoreSelection$1, {
	      value: _restoreSelection2$1
	    });
	    Object.defineProperty(this, _registerCommands$7, {
	      value: _registerCommands2$7
	    });
	    Object.defineProperty(this, _videoDialog, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll$2, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll$2)[_handleEditorScroll$2].bind(this)
	    });
	    Object.defineProperty(this, _lastSelection$1, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$7)[_registerCommands$7]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$6)[_registerComponents$6]();
	  }
	  static getName() {
	    return 'Video';
	  }
	  static getNodes(editor) {
	    return [VideoNode];
	  }
	  importBBCode() {
	    return {
	      video: () => ({
	        conversion: node => {
	          // [video type={type} width={width} height={height}]{url}[/video]
	          const src = node.getContent().trim();
	          const width = Number(node.getAttribute('width'));
	          const height = Number(node.getAttribute('height'));
	          if (validateVideoUrl(src)) {
	            return {
	              node: $createVideoNode({
	                src: sanitizeUrl(src),
	                width,
	                height
	              })
	            };
	          }
	          return {
	            node: ui_lexical_core.$createTextNode(node.toString())
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      video: lexicalNode => {
	        const attributes = {};
	        const width = lexicalNode.getWidth();
	        const height = lexicalNode.getHeight();
	        if (main_core.Type.isNumber(width) && main_core.Type.isNumber(height)) {
	          attributes.width = width;
	          attributes.height = height;
	        }
	        const provider = lexicalNode.getProvider();
	        if (main_core.Type.isStringFilled(provider)) {
	          attributes.type = provider;
	        }
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'video',
	            inline: false,
	            attributes
	          }),
	          after: elementNode => {
	            elementNode.setChildren([scheme.createText(lexicalNode.getSrc())]);
	          }
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: VideoNode
	      }],
	      bbcodeMap: {
	        video: 'video'
	      }
	    };
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].destroy();
	    }
	  }
	}
	function _registerCommands2$7() {
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_VIDEO_COMMAND, payload => {
	    if (main_core.Type.isPlainObject(payload) && validateVideoUrl(payload.src)) {
	      const videoNode = $createVideoNode({
	        src: ui_videoService.VideoService.getEmbeddedUrl(payload.src) || payload.src,
	        width: payload.width,
	        height: payload.height
	      });
	      ui_lexical_utils.$insertNodeToNearestRoot(videoNode);
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(INSERT_VIDEO_DIALOG_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$1)[_lastSelection$1] = selection.clone();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].destroy();
	    }
	    this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND);
	    babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] = new VideoDialog({
	      // for an embedded popup: document.body -> this.getEditor().getScrollerContainer()
	      targetContainer: document.body,
	      events: {
	        onSave: () => {
	          const url = babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].getVideoUrl();
	          if (!main_core.Type.isStringFilled(url)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].hide();
	            return;
	          }
	          if (!validateVideoUrl(url)) {
	            babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].showError(main_core.Loc.getMessage('TEXT_EDITOR_INVALID_URL'));
	            return;
	          }
	          this.getEditor().dispatchCommand(INSERT_VIDEO_COMMAND, {
	            src: url
	          });
	          babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].hide();
	        },
	        onInput: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].clearError();
	        },
	        onCancel: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].hide();
	        },
	        onShow: () => {
	          if ($adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].getPopup(), this.getEditor())) {
	            main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$2)[_onEditorScroll$2]);
	            this.getEditor().highlightSelection();
	          }
	        },
	        onClose: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy$1)[_handleDialogDestroy$1]();
	        },
	        onDestroy: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy$1)[_handleDialogDestroy$1]();
	        }
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].hide();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].isShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _restoreSelection2$1() {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) && babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$1)[_lastSelection$1] !== null) {
	    ui_lexical_core.$setSelection(babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$1)[_lastSelection$1]);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$1)[_lastSelection$1] = null;
	    return true;
	  }
	  return false;
	}
	function _handleDialogDestroy2$1() {
	  babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] = null;
	  main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$2)[_onEditorScroll$2]);
	  this.getEditor().resetHighlightSelection();
	  this.getEditor().update(() => {
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$1)[_restoreSelection$1]()) {
	      this.getEditor().focus();
	    }
	  });
	}
	function _handleEditorScroll2$2() {
	  this.getEditor().update(() => {
	    $adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].getPopup(), this.getEditor());
	  });
	}
	function _registerComponents2$6() {
	  this.getEditor().getComponentRegistry().register('video', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --insert-video"></span>');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_VIDEO'));
	    button.subscribe('onClick', () => {
	      if (babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _videoDialog)[_videoDialog].isShown()) {
	        return;
	      }
	      this.getEditor().focus(() => {
	        this.getEditor().dispatchCommand(INSERT_VIDEO_DIALOG_COMMAND);
	      });
	    });
	    return button;
	  });
	}



	var Video = /*#__PURE__*/Object.freeze({
		VideoNode: VideoNode,
		$createVideoNode: $createVideoNode,
		$isVideoNode: $isVideoNode,
		INSERT_VIDEO_COMMAND: INSERT_VIDEO_COMMAND,
		INSERT_VIDEO_DIALOG_COMMAND: INSERT_VIDEO_DIALOG_COMMAND,
		VideoPlugin: VideoPlugin
	});

	function printFormatProperties(nodeOrSelection) {
	  let str = FORMAT_PREDICATES.map(predicate => predicate(nodeOrSelection)).filter(Boolean).join(', ').toLocaleLowerCase();
	  if (str !== '') {
	    str = `format: ${str}`;
	  }
	  return str;
	}

	function printNode(node) {
	  if ($isCodeTokenNode(node)) {
	    const codeTokenNode = node;
	    return `{ ${codeTokenNode.__highlightType}: "${normalize(codeTokenNode.getTextContent())}" }`;
	  }
	  if ($isCodeNode(node)) {
	    const codeTokenNode = node;
	    return `{ children: ${codeTokenNode.getChildrenSize()} }`;
	  }
	  if (ui_lexical_core.$isTextNode(node)) {
	    const text = node.getTextContent();
	    const title = text.length === 0 ? '(empty)' : `"${normalize(text)}"`;
	    const properties = printAllTextNodeProperties(node);
	    return [title, properties.length > 0 ? `{ ${properties} }` : null].filter(Boolean).join(' ').trim();
	  }
	  if ($isFileImageNode(node)) {
	    const fileImageNode = node;
	    return `{ id: ${fileImageNode.getId()}, width: ${fileImageNode.getWidth()}, height: ${fileImageNode.getHeight()} }`;
	  }
	  if ($isFileNode(node)) {
	    const fileNode = node;
	    return `{ id: ${fileNode.getId()} }`;
	  }
	  if ($isFileVideoNode(node)) {
	    const fileVideoNode = node;
	    return `{ id: ${fileVideoNode.getId()} }`;
	  }
	  if ($isSmileyNode(node)) {
	    const smileyNode = node;
	    return `{ typing: ${smileyNode.getTyping()}, width: ${smileyNode.getWidth()}, height: ${smileyNode.getHeight()} }`;
	  }
	  if ($isVideoNode(node)) {
	    const videoNode = node;
	    return `{ width: ${videoNode.getWidth()}, height: ${videoNode.getHeight()} }`;
	  }
	  if ($isMentionNode(node)) {
	    const mentionNode = node;
	    return `{ entityId: ${mentionNode.getEntityId()}, id: ${mentionNode.getId()} }`;
	  }
	  if ($isImageNode(node)) {
	    const imageNode = node;
	    return `{ width: ${imageNode.getWidth()}, height: ${imageNode.getHeight()} }`;
	  }
	  if (ui_lexical_link.$isLinkNode(node)) {
	    const linkNode = node;
	    const link = linkNode.getURL();
	    const title = link.length === 0 ? '(empty)' : `"${normalize(link)}"`;
	    const properties = printAllLinkNodeProperties(linkNode);
	    return [title, properties.length > 0 ? `{ ${properties} }` : null].filter(Boolean).join(' ').trim();
	  }
	  return '';
	}
	function normalize(text) {
	  return Object.entries(NON_SINGLE_WIDTH_CHARS_REPLACEMENT).reduce((acc, [key, value]) => acc.replace(new RegExp(key, 'g'), String(value)), text);
	}
	function printAllTextNodeProperties(node) {
	  return [printFormatProperties(node), printDetailProperties(node), printModeProperties(node)].filter(Boolean).join(', ');
	}
	function printAllLinkNodeProperties(node) {
	  return [printTargetProperties(node), printRelProperties(node), printTitleProperties(node)].filter(Boolean).join(', ');
	}
	function printTargetProperties(node) {
	  let str = node.getTarget();
	  if (!main_core.Type.isNil(str)) {
	    str = `target: ${str}`;
	  }
	  return str;
	}
	function printRelProperties(node) {
	  let str = node.getRel();
	  if (!main_core.Type.isNil(str)) {
	    str = `rel: ${str}`;
	  }
	  return str;
	}
	function printTitleProperties(node) {
	  let str = node.getTitle();
	  if (!main_core.Type.isNil(str)) {
	    str = `title: ${str}`;
	  }
	  return str;
	}
	function printDetailProperties(nodeOrSelection) {
	  let str = DETAIL_PREDICATES.map(predicate => predicate(nodeOrSelection)).filter(Boolean).join(', ').toLocaleLowerCase();
	  if (str !== '') {
	    str = `detail: ${str}`;
	  }
	  return str;
	}
	function printModeProperties(nodeOrSelection) {
	  let str = MODE_PREDICATES.map(predicate => predicate(nodeOrSelection)).filter(Boolean).join(', ').toLocaleLowerCase();
	  if (str !== '') {
	    str = `mode: ${str}`;
	  }
	  return str;
	}

	function printNodeSelection(selection) {
	  if (!ui_lexical_core.$isNodeSelection(selection)) {
	    return '';
	  }
	  return `: node\n  └ [${[...selection._nodes].join(', ')}]`;
	}

	function printRangeSelection(selection) {
	  let res = '';
	  const formatText = printFormatProperties(selection);
	  res += `: range ${formatText !== '' ? `{ ${formatText} }` : ''} ${selection.style !== '' ? `{ style: ${selection.style} } ` : ''}`;
	  const anchor = selection.anchor;
	  const focus = selection.focus;
	  const anchorOffset = anchor.offset;
	  const focusOffset = focus.offset;
	  res += `\n  ├ anchor { key: ${anchor.key}, offset: ${anchorOffset === null ? 'null' : anchorOffset}, type: ${anchor.type} }`;
	  res += `\n  └ focus { key: ${focus.key}, offset: ${focusOffset === null ? 'null' : focusOffset}, type: ${focus.type} }`;
	  return res;
	}

	function printTableSelection(selection) {
	  return `: table\n  └ { table: ${selection.tableKey}, anchorCell: ${selection.anchor.key}, focusCell: ${selection.focus.key} }`;
	}

	function visitTree(currentNode, visitor, indent = []) {
	  const childNodes = currentNode.getChildren();
	  const childNodesLength = childNodes.length;
	  childNodes.forEach((childNode, i) => {
	    visitor(childNode, indent.concat(i === childNodesLength - 1 ? SYMBOLS.isLastChild : SYMBOLS.hasNextSibling));
	    if (ui_lexical_core.$isElementNode(childNode)) {
	      visitTree(childNode, visitor, indent.concat(i === childNodesLength - 1 ? SYMBOLS.ancestorIsLastChild : SYMBOLS.ancestorHasNextSibling));
	    }
	  });
	}

	/* eslint-disable no-underscore-dangle */
	function generateContent(editor) {
	  const editorState = editor.getEditorState();

	  // if (exportDOM)
	  // {
	  // 	let htmlString = '';
	  // 	editorState.read(() => {
	  // 		htmlString = printPrettyHTML($generateHtmlFromNodes(editor));
	  // 	});
	  // 	return htmlString;
	  // }

	  let res = ' root\n';
	  const selectionString = editorState.read(() => {
	    const selection = ui_lexical_core.$getSelection();
	    visitTree(ui_lexical_core.$getRoot(), (node, indent) => {
	      const nodeKey = node.getKey();
	      const nodeKeyDisplay = `(${nodeKey})`;
	      const typeDisplay = node.getType() || '';
	      const isSelected = node.isSelected();
	      res += `${isSelected ? SYMBOLS.selectedLine : ' '} ${indent.join(' ')} ${nodeKeyDisplay} ${typeDisplay} ${printNode(node)}\n`;
	      res += printSelectedCharsLine({
	        indent,
	        isSelected,
	        node,
	        nodeKeyDisplay,
	        selection,
	        typeDisplay
	      });
	    });
	    if (selection === null) {
	      return ': null';
	    }
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      return printRangeSelection(selection);
	    }
	    if (ui_lexical_table.$isTableSelection(selection)) {
	      return printTableSelection(selection);
	    }
	    return printNodeSelection(selection);
	  });
	  res += `\n selection${selectionString}`;
	  return res;
	}
	function printSelectedCharsLine({
	  indent,
	  isSelected,
	  node,
	  nodeKeyDisplay,
	  selection,
	  typeDisplay
	}) {
	  // No selection or node is not selected.
	  if (!ui_lexical_core.$isTextNode(node) || !ui_lexical_core.$isRangeSelection(selection) || !isSelected || ui_lexical_core.$isElementNode(node)) {
	    return '';
	  }

	  // No selected characters.
	  const anchor = selection.anchor;
	  const focus = selection.focus;
	  if (node.getTextContent() === '' || anchor.getNode() === selection.focus.getNode() && anchor.offset === focus.offset) {
	    return '';
	  }
	  const [start, end] = $getSelectionStartEnd(node, selection);
	  if (start === end) {
	    return '';
	  }
	  const selectionLastIndent = indent[indent.length - 1] === SYMBOLS.hasNextSibling ? SYMBOLS.ancestorHasNextSibling : SYMBOLS.ancestorIsLastChild;
	  const indentionChars = [...indent.slice(0, -1), selectionLastIndent];
	  const unselectedChars = Array.from({
	    length: start + 1
	  }).fill(' ');
	  const selectedChars = Array.from({
	    length: end - start
	  }).fill(SYMBOLS.selectedChar);
	  const paddingLength = typeDisplay.length + 3; // 2 for the spaces around + 1 for the double quote.
	  const nodePrintSpaces = Array.from({
	    length: nodeKeyDisplay.length + paddingLength
	  }).fill(' ');
	  return `${[SYMBOLS.selectedLine, indentionChars.join(' '), [...nodePrintSpaces, ...unselectedChars, ...selectedChars].join('')].join(' ')}\n`;
	}
	function $getSelectionStartEnd(node, selection) {
	  const anchorAndFocus = selection.getStartEndPoints();
	  if (ui_lexical_core.$isNodeSelection(selection) || anchorAndFocus === null) {
	    return [-1, -1];
	  }
	  const [anchor, focus] = anchorAndFocus;
	  const textContent = node.getTextContent();
	  const textLength = textContent.length;
	  let start = -1;
	  let end = -1;

	  // Only one node is being selected.
	  if (anchor.type === 'text' && focus.type === 'text') {
	    const anchorNode = anchor.getNode();
	    const focusNode = focus.getNode();
	    if (anchorNode === focusNode && node === anchorNode && anchor.offset !== focus.offset) {
	      [start, end] = anchor.offset < focus.offset ? [anchor.offset, focus.offset] : [focus.offset, anchor.offset];
	    } else if (node === anchorNode) {
	      [start, end] = anchorNode.isBefore(focusNode) ? [anchor.offset, textLength] : [0, anchor.offset];
	    } else if (node === focusNode) {
	      [start, end] = focusNode.isBefore(anchorNode) ? [focus.offset, textLength] : [0, focus.offset];
	    } else {
	      // Node is within selection but not the anchor nor focus.
	      [start, end] = [0, textLength];
	    }
	  }

	  // Account for non-single width characters.
	  const numNonSingleWidthCharBeforeSelection = (textContent.slice(0, start).match(NON_SINGLE_WIDTH_CHARS_REGEX) || []).length;
	  const numNonSingleWidthCharInSelection = (textContent.slice(start, end).match(NON_SINGLE_WIDTH_CHARS_REGEX) || []).length;
	  return [start + numNonSingleWidthCharBeforeSelection, end + numNonSingleWidthCharBeforeSelection + numNonSingleWidthCharInSelection];
	}

	function createHashCode(s) {
	  return [...s].reduce((hash, c) => Math.trunc(Math.imul(31, hash) + c.codePointAt(0)), 0);
	}

	function $isRootEmpty(trim = true) {
	  const root = ui_lexical_core.$getRoot();
	  let text = root.getTextContent();
	  if (trim) {
	    text = text.trim();
	  }
	  if (text !== '') {
	    return false;
	  }
	  const children = root.getChildren();
	  const childrenLength = children.length;
	  if (childrenLength > 1) {
	    return false;
	  }
	  for (let i = 0; i < childrenLength; i++) {
	    const topBlock = children[i];
	    if (ui_lexical_core.$isDecoratorNode(topBlock)) {
	      return false;
	    }
	    if (ui_lexical_core.$isElementNode(topBlock)) {
	      if (!ui_lexical_core.$isParagraphNode(topBlock)) {
	        return false;
	      }
	      if (topBlock.__indent !== 0) {
	        return false;
	      }
	      const topBlockChildren = topBlock.getChildren();
	      const topBlockChildrenLength = topBlockChildren.length;
	      for (let s = 0; s < topBlockChildrenLength; s++) {
	        const child = topBlockChildren[i];
	        if (!ui_lexical_core.$isTextNode(child)) {
	          return false;
	        }
	      }
	    }
	  }
	  return true;
	}

	const defaultTheme = {
	  blockCursor: 'ui-text-editor__block-cursor',
	  indent: 'ui-text-editor__indent',
	  ltr: 'ui-text-editor__ltr',
	  rtl: 'ui-text-editor__rtl',
	  heading: {
	    h1: 'ui-typography-heading-h1',
	    h2: 'ui-typography-heading-h2',
	    h3: 'ui-typography-heading-h3',
	    h4: 'ui-typography-heading-h4',
	    h5: 'ui-typography-heading-h5',
	    h6: 'ui-typography-heading-h6'
	  },
	  hashtag: 'ui-typography-hashtag',
	  link: 'ui-typography-link',
	  list: {
	    listitem: 'ui-typography-li',
	    nested: {
	      listitem: 'ui-text-editor__nestedListItem'
	    },
	    olDepth: ['ui-typography-ol ui-text-editor__ol1', 'ui-typography-ol ui-text-editor__ol2', 'ui-typography-ol ui-text-editor__ol3', 'ui-typography-ol ui-text-editor__ol4', 'ui-typography-ol ui-text-editor__ol5'],
	    ul: 'ui-typography-ul'
	  },
	  paragraph: 'ui-typography-paragraph ui-text-editor__paragraph',
	  text: {
	    bold: 'ui-typography-text-bold',
	    code: 'ui-typography-text-code',
	    italic: 'ui-typography-text-italic',
	    strikethrough: 'ui-typography-text-strikethrough',
	    subscript: 'ui-typography-text-subscript',
	    superscript: 'ui-typography-text-superscript',
	    underline: 'ui-typography-text-underline',
	    underlineStrikethrough: 'ui-typography-text-underline-strikethrough'
	  },
	  mention: 'ui-typography-mention',
	  quote: 'ui-typography-quote',
	  spoiler: {
	    container: 'ui-typography-spoiler',
	    title: 'ui-typography-spoiler-title ui-icon-set__scope',
	    content: 'ui-typography-spoiler-content'
	  },
	  smiley: 'ui-typography-smiley',
	  code: 'ui-typography-code',
	  codeHighlight: {
	    operator: 'ui-typography-token-operator',
	    punctuation: 'ui-typography-token-punctuation',
	    comment: 'ui-typography-token-comment',
	    word: 'ui-typography-token-word',
	    keyword: 'ui-typography-token-keyword',
	    boolean: 'ui-typography-token-boolean',
	    regex: 'ui-typography-token-regex',
	    string: 'ui-typography-token-string',
	    number: 'ui-typography-token-number',
	    semicolon: 'ui-typography-token-semicolon',
	    bracket: 'ui-typography-token-bracket',
	    brace: 'ui-typography-token-brace',
	    parentheses: 'ui-typography-token-parentheses'
	  },
	  table: 'ui-typography-table',
	  tableRow: 'ui-typography-table-row',
	  tableCell: 'ui-typography-table-cell',
	  tableCellHeader: 'ui-typography-table-cell-header',
	  tableSelection: 'ui-typography-table-selection',
	  image: {
	    container: 'ui-typography-image-container ui-text-editor__image-container',
	    img: 'ui-typography-image'
	  },
	  video: {
	    container: 'ui-typography-video-container ui-text-editor__video-container',
	    object: 'ui-typography-video-object ui-text-editor__video-object'
	  },
	  file: 'ui-text-editor__file'
	};

	let _Symbol$iterator;
	var _pluginConstructors = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("pluginConstructors");
	var _plugins = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("plugins");
	var _availablePlugins = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("availablePlugins");
	_Symbol$iterator = Symbol.iterator;
	class PluginCollection {
	  constructor(builtinPlugins = [], plugins = [], pluginsToRemove = []) {
	    Object.defineProperty(this, _pluginConstructors, {
	      writable: true,
	      value: new Map()
	    });
	    Object.defineProperty(this, _plugins, {
	      writable: true,
	      value: new Map()
	    });
	    Object.defineProperty(this, _availablePlugins, {
	      writable: true,
	      value: new Map()
	    });
	    for (const pluginConstructor of builtinPlugins) {
	      if (pluginConstructor.getName()) {
	        babelHelpers.classPrivateFieldLooseBase(this, _availablePlugins)[_availablePlugins].set(pluginConstructor.getName(), pluginConstructor);
	      }
	    }
	    for (const plugin of plugins) {
	      if (main_core.Type.isFunction(plugin) && plugin.getName() && !babelHelpers.classPrivateFieldLooseBase(this, _availablePlugins)[_availablePlugins].has(plugin.getName())) {
	        babelHelpers.classPrivateFieldLooseBase(this, _availablePlugins)[_availablePlugins].set(plugin.getName(), plugin);
	      }
	    }
	    const pluginsToLoad = plugins.filter(plugin => {
	      if (pluginsToRemove.includes(plugin)) {
	        return false;
	      }
	      if (main_core.Type.isFunction(plugin) && pluginsToRemove.includes(plugin.getName())) {
	        return false;
	      }
	      return !pluginsToRemove.includes(babelHelpers.classPrivateFieldLooseBase(this, _availablePlugins)[_availablePlugins].get(plugin));
	    });
	    pluginsToLoad.map(plugin => {
	      return main_core.Type.isFunction(plugin) ? plugin : babelHelpers.classPrivateFieldLooseBase(this, _availablePlugins)[_availablePlugins].get(plugin);
	    }).forEach(pluginConstructor => {
	      if (main_core.Type.isFunction(pluginConstructor)) {
	        babelHelpers.classPrivateFieldLooseBase(this, _pluginConstructors)[_pluginConstructors].set(pluginConstructor.getName(), pluginConstructor);
	      }
	    });
	  }
	  init(textEditor) {
	    const instances = [];
	    for (const [, PluginConstruct] of babelHelpers.classPrivateFieldLooseBase(this, _pluginConstructors)[_pluginConstructors]) {
	      const plugin = new PluginConstruct(textEditor);
	      if (!(plugin instanceof BasePlugin)) {
	        throw new TypeError('TextEditor: a plugin must be an instance of TextEditor.BasePlugin.');
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _plugins)[_plugins].set(PluginConstruct.getName(), plugin);
	      instances.push(plugin);
	    }
	    instances.forEach(instance => {
	      instance.afterInit();
	    });
	  }
	  getConstructors() {
	    return [...babelHelpers.classPrivateFieldLooseBase(this, _pluginConstructors)[_pluginConstructors].values()];
	  }
	  getPlugins() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins)[_plugins];
	  }
	  [_Symbol$iterator]() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins)[_plugins][Symbol.iterator]();
	  }
	  get(key) {
	    const name = main_core.Type.isFunction(key) ? key.getName() : key;
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins)[_plugins].get(name) || null;
	  }
	  has(key) {
	    const name = main_core.Type.isFunction(key) ? key.getName() : key;
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins)[_plugins].has(name);
	  }
	}

	var _components = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("components");
	var _normalizeName = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("normalizeName");
	class ComponentRegistry {
	  constructor() {
	    Object.defineProperty(this, _components, {
	      writable: true,
	      value: new Map()
	    });
	  }
	  register(name, callback) {
	    babelHelpers.classPrivateFieldLooseBase(this, _components)[_components].set(babelHelpers.classPrivateFieldLooseBase(this.constructor, _normalizeName)[_normalizeName](name), {
	      callback
	    });
	  }
	  create(name) {
	    const component = babelHelpers.classPrivateFieldLooseBase(this, _components)[_components].get(babelHelpers.classPrivateFieldLooseBase(this.constructor, _normalizeName)[_normalizeName](name));
	    return component ? component.callback() : null;
	  }
	}
	function _normalizeName2(name) {
	  return String(name).toLowerCase();
	}
	Object.defineProperty(ComponentRegistry, _normalizeName, {
	  value: _normalizeName2
	});

	/* eslint-disable @bitrix24/bitrix24-rules/no-native-dom-methods */
	var _editor$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("editor");
	var _nodeTypeToBBCodeType = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("nodeTypeToBBCodeType");
	var _nodeValidation = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("nodeValidation");
	var _initNodeValidation = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initNodeValidation");
	var _handleNodeTransform = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleNodeTransform");
	class SchemeValidation {
	  constructor(editor) {
	    Object.defineProperty(this, _handleNodeTransform, {
	      value: _handleNodeTransform2
	    });
	    Object.defineProperty(this, _initNodeValidation, {
	      value: _initNodeValidation2
	    });
	    Object.defineProperty(this, _editor$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _nodeTypeToBBCodeType, {
	      writable: true,
	      value: new Map()
	    });
	    Object.defineProperty(this, _nodeValidation, {
	      writable: true,
	      value: new Map()
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _editor$1)[_editor$1] = editor;
	    babelHelpers.classPrivateFieldLooseBase(this, _initNodeValidation)[_initNodeValidation]();
	  }
	  isNodeAllowed(parent, child) {
	    const parentCode = main_core.Type.isString(parent) ? parent : babelHelpers.classPrivateFieldLooseBase(this, _nodeTypeToBBCodeType)[_nodeTypeToBBCodeType].get(parent.getType());
	    const childCode = main_core.Type.isString(child) ? child : babelHelpers.classPrivateFieldLooseBase(this, _nodeTypeToBBCodeType)[_nodeTypeToBBCodeType].get(child.getType());
	    if (!parentCode) {
	      // eslint-disable-next-line no-console
	      console.warn(`TextEditor: parent node (${parent.getType()}) doesn't have a bbcode tag.`);
	    }
	    if (!childCode) {
	      // eslint-disable-next-line no-console
	      console.warn(`TextEditor: child node (${child.getType()}) doesn't have a bbcode tag.`);
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _editor$1)[_editor$1].getBBCodeScheme().isChildAllowed(parentCode, childCode);
	  }
	  findAllowedParent(node) {
	    let parent = node.getParent();
	    while (parent !== null) {
	      if (this.isNodeAllowed(parent, node)) {
	        return parent;
	      }
	      parent = parent.getParent();
	    }
	    return null;
	  }
	  moveToNextParent(node, removeOnFail = true) {
	    let parent = node.getParent();
	    let targetNode = null;
	    while (parent.getParent() !== null) {
	      if (this.isNodeAllowed(parent.getParent(), node)) {
	        targetNode = parent;
	        break;
	      }
	      parent = parent.getParent();
	    }
	    if (targetNode === null) {
	      if (removeOnFail) {
	        node.remove();
	      }
	      return false;
	    }
	    if (ui_lexical_core.$isRootNode(targetNode.getParent()) && (ui_lexical_core.$isTextNode(node) || ui_lexical_core.$isElementNode(node) && node.isInline())) {
	      targetNode.insertBefore(ui_lexical_core.$createParagraphNode().append(node));
	      return true;
	    }
	    targetNode.insertBefore(node);
	    return true;
	  }
	}
	function _initNodeValidation2() {
	  const handleNodeTransform = babelHelpers.classPrivateFieldLooseBase(this, _handleNodeTransform)[_handleNodeTransform].bind(this);
	  for (const [, plugin] of babelHelpers.classPrivateFieldLooseBase(this, _editor$1)[_editor$1].getPlugins()) {
	    const validation = plugin.validateScheme();
	    if (!main_core.Type.isPlainObject(validation)) {
	      continue;
	    }
	    if (main_core.Type.isArrayFilled(validation.nodes)) {
	      validation.nodes.forEach(nodeValidation => {
	        babelHelpers.classPrivateFieldLooseBase(this, _editor$1)[_editor$1].registerNodeTransform(nodeValidation.nodeClass, handleNodeTransform);
	        if (main_core.Type.isFunction(nodeValidation.validate)) {
	          babelHelpers.classPrivateFieldLooseBase(this, _nodeValidation)[_nodeValidation].set(nodeValidation.nodeClass.getType(), {
	            validate: nodeValidation.validate
	          });
	        }
	      });
	    }
	    if (main_core.Type.isPlainObject(validation.bbcodeMap)) {
	      for (const [nodeType, bbcodeTag] of Object.entries(validation.bbcodeMap)) {
	        babelHelpers.classPrivateFieldLooseBase(this, _nodeTypeToBBCodeType)[_nodeTypeToBBCodeType].set(nodeType, bbcodeTag);
	      }
	    }
	  }
	}
	function _handleNodeTransform2(node) {
	  const {
	    validate = null
	  } = babelHelpers.classPrivateFieldLooseBase(this, _nodeValidation)[_nodeValidation].get(node.getType()) || {};
	  if (validate !== null && validate(node, this) === true) {
	    return;
	  }
	  const parent = node.getParent();
	  if (this.isNodeAllowed(parent, node)) {
	    return;
	  }

	  // eslint-disable-next-line no-console
	  console.warn(`TextEditor: ${node.getType()} is not allowed in ${parent.getType()}`);
	  this.moveToNextParent(node);
	}

	class RichTextPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    this.cleanUpRegister(ui_lexical_richText.registerRichText(editor.getLexicalEditor()));
	  }
	  static getName() {
	    return 'RichText';
	  }
	}

	class ClipboardPlainTableNode extends ui_lexical_core.ElementNode {
	  static getType() {
	    return 'plain-table-node';
	  }
	  static clone(node) {
	    throw new Error('Not implemented');
	  }
	  static importJSON(serializedNode) {
	    throw new Error('Not implemented');
	  }
	  exportJSON() {
	    throw new Error('Not implemented');
	  }
	  static importDOM() {
	    return {
	      table: () => {
	        return {
	          conversion: convertTableToPlainText,
	          priority: 0
	        };
	      },
	      tr: () => {
	        return {
	          conversion: () => ({
	            node: null
	          }),
	          priority: 0
	        };
	      },
	      td: () => {
	        return {
	          conversion: () => ({
	            node: null
	          }),
	          priority: 0
	        };
	      },
	      th: () => {
	        return {
	          conversion: () => ({
	            node: null
	          }),
	          priority: 0
	        };
	      }
	    };
	  }
	}
	function convertTableToPlainText(table) {
	  const nodes = [];
	  const rows = [...table.rows];
	  for (const row of rows) {
	    if (nodes.length > 0) {
	      nodes.push(ui_lexical_core.$createLineBreakNode());
	    }
	    const cells = [];
	    for (const cell of row.cells) {
	      if (cells.length > 0) {
	        // cells.push($createTabNode());
	        cells.push(ui_lexical_core.$createTextNode(' '));
	      }
	      cells.push(ui_lexical_core.$createTextNode(cell.textContent.trim()));
	    }
	    nodes.push(...cells);
	  }
	  return {
	    node: nodes
	  };
	}

	class ClipboardPlugin extends BasePlugin {
	  static getName() {
	    return 'Clipboard';
	  }
	  static getNodes(editor) {
	    const nodes = [];
	    const tablePluginExists = editor.getPlugins().getConstructors().some(plugin => {
	      return plugin.getName() === 'Table';
	    });
	    if (!tablePluginExists) {
	      nodes.push(ClipboardPlainTableNode);
	    }
	    return nodes;
	  }
	}

	var _registerComponents$7 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class BoldPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$7, {
	      value: _registerComponents2$7
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$7)[_registerComponents$7]();
	  }
	  static getName() {
	    return 'Bold';
	  }
	  importBBCode() {
	    return {
	      b: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      }),
	      color: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      }),
	      background: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      }),
	      size: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      'text:bold': (lexicalNode, node) => {
	        if (lexicalNode.hasFormat('bold')) {
	          return wrapNodeWith(node, 'b', this.getEditor());
	        }
	        return null;
	      }
	    };
	  }
	}
	function _registerComponents2$7() {
	  this.getEditor().getComponentRegistry().register('bold', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --bold"></span>');
	    button.setFormat('bold');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_BOLD', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘B' : 'Ctrl+B'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, 'bold');
	      });
	    });
	    return button;
	  });
	}



	var Bold = /*#__PURE__*/Object.freeze({
		BoldPlugin: BoldPlugin
	});

	var _registerComponents$8 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class ItalicPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$8, {
	      value: _registerComponents2$8
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$8)[_registerComponents$8]();
	  }
	  static getName() {
	    return 'Italic';
	  }
	  importBBCode() {
	    return {
	      i: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      'text:italic': (lexicalNode, node) => {
	        if (lexicalNode.hasFormat('italic')) {
	          return wrapNodeWith(node, 'i', this.getEditor());
	        }
	        return null;
	      }
	    };
	  }
	}
	function _registerComponents2$8() {
	  this.getEditor().getComponentRegistry().register('italic', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --italic"></span>');
	    button.setFormat('italic');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_ITALIC', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘I' : 'Ctrl+I'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, 'italic');
	      });
	    });
	    return button;
	  });
	}



	var Italic = /*#__PURE__*/Object.freeze({
		ItalicPlugin: ItalicPlugin
	});

	var _registerKeyModifierCommand = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerKeyModifierCommand");
	var _registerComponents$9 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class StrikethroughPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$9, {
	      value: _registerComponents2$9
	    });
	    Object.defineProperty(this, _registerKeyModifierCommand, {
	      value: _registerKeyModifierCommand2
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$9)[_registerComponents$9]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerKeyModifierCommand)[_registerKeyModifierCommand]();
	  }
	  static getName() {
	    return 'Strikethrough';
	  }
	  importBBCode() {
	    return {
	      s: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      }),
	      del: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      'text:strikethrough': (lexicalNode, node) => {
	        if (lexicalNode.hasFormat('strikethrough')) {
	          return wrapNodeWith(node, 's', this.getEditor());
	        }
	        return null;
	      }
	    };
	  }
	}
	function _registerKeyModifierCommand2() {
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_core.KEY_MODIFIER_COMMAND, payload => {
	    const event = payload;
	    const {
	      code,
	      ctrlKey,
	      metaKey,
	      shiftKey
	    } = event;
	    if (code === 'KeyX' && (ctrlKey || metaKey) && shiftKey) {
	      event.preventDefault();
	      this.getEditor().dispatchCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, 'strikethrough');
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_NORMAL));
	}
	function _registerComponents2$9() {
	  this.getEditor().getComponentRegistry().register('strikethrough', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --strikethrough"></span>');
	    button.setFormat('strikethrough');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_STRIKETHROUGH', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘⇧X' : 'Ctrl+Shift+X'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, 'strikethrough');
	      });
	    });
	    return button;
	  });
	}



	var Strikethrough = /*#__PURE__*/Object.freeze({
		StrikethroughPlugin: StrikethroughPlugin
	});

	var _registerComponents$a = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class UnderlinePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$a, {
	      value: _registerComponents2$a
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$a)[_registerComponents$a]();
	  }
	  static getName() {
	    return 'Underline';
	  }
	  importBBCode() {
	    return {
	      u: () => ({
	        conversion: convertTextFormatElement,
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      'text:underline': (lexicalNode, node) => {
	        if (lexicalNode.hasFormat('underline')) {
	          return wrapNodeWith(node, 'u', this.getEditor());
	        }
	        return null;
	      }
	    };
	  }
	}
	function _registerComponents2$a() {
	  this.getEditor().getComponentRegistry().register('underline', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --underline"></span>');
	    button.setFormat('underline');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_UNDERLINE', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘U' : 'Ctrl+U'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(ui_lexical_core.FORMAT_TEXT_COMMAND, 'underline');
	      });
	    });
	    return button;
	  });
	}



	var Underline = /*#__PURE__*/Object.freeze({
		UnderlinePlugin: UnderlinePlugin
	});

	const CLEAR_FORMATTING_COMMAND = ui_lexical_core.createCommand('CLEAR_FORMATTING_COMMAND');
	var _registerCommands$8 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerComponents$b = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class ClearFormatPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$b, {
	      value: _registerComponents2$b
	    });
	    Object.defineProperty(this, _registerCommands$8, {
	      value: _registerCommands2$8
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$8)[_registerCommands$8]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$b)[_registerComponents$b]();
	  }
	  static getName() {
	    return 'ClearFormat';
	  }
	}
	function _registerCommands2$8() {
	  this.cleanUpRegister(this.getEditor().registerCommand(CLEAR_FORMATTING_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) && !ui_lexical_table.$isTableSelection(selection)) {
	      return false;
	    }
	    const anchor = selection.anchor;
	    const focus = selection.focus;
	    const nodes = selection.getNodes();
	    const extractedNodes = selection.extract();
	    if (anchor.key === focus.key && anchor.offset === focus.offset) {
	      return false;
	    }
	    nodes.forEach((node, idx) => {
	      // We split the first and last node by the selection
	      // So that we don't format unselected text inside those nodes
	      if (ui_lexical_core.$isTextNode(node)) {
	        // Use a separate variable to ensure TS does not lose the refinement
	        let textNode = node;
	        if (idx === 0 && anchor.offset !== 0) {
	          textNode = textNode.splitText(anchor.offset)[1] || textNode;
	        }
	        if (idx === nodes.length - 1) {
	          textNode = textNode.splitText(focus.offset)[0] || textNode;
	        }
	        /**
	         * If the selected text has one format applied
	         * selecting a portion of the text, could
	         * clear the format to the wrong portion of the text.
	         *
	         * The cleared text is based on the length of the selected text.
	         */
	        // We need this in case the selected text only has one format
	        const extractedTextNode = extractedNodes[0];
	        if (nodes.length === 1 && ui_lexical_core.$isTextNode(extractedTextNode)) {
	          textNode = extractedTextNode;
	        }
	        if (textNode.__style !== '') {
	          textNode.setStyle('');
	        }
	        if (textNode.__format !== 0) {
	          textNode.setFormat(0);
	          ui_lexical_utils.$getNearestBlockElementAncestorOrThrow(textNode).setFormat('');
	        }
	      }
	      /* else if ($isHeadingNode(node) || $isQuoteNode(node))
	      {
	      	node.replace($createParagraphNode(), true);
	      } */
	    });

	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR));
	}
	function _registerComponents2$b() {
	  this.getEditor().getComponentRegistry().register('clear-format', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --remove-formatting"></span>');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_CLEAR_FORMATTING'));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        this.getEditor().dispatchCommand(CLEAR_FORMATTING_COMMAND);
	      });
	    });
	    return button;
	  });
	}

	let _$9 = t => t,
	  _t$9,
	  _t2$6,
	  _t3$1;
	var _popup$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _editMode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("editMode");
	var _autoLinkMode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("autoLinkMode");
	var _linkUrl = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("linkUrl");
	var _targetContainer$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetContainer");
	var _refs$6 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _handleSaveBtnClick$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleSaveBtnClick");
	var _handleLinkTextBoxKeyDown = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleLinkTextBoxKeyDown");
	var _handleCancelBtnClick$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCancelBtnClick");
	var _handleEditBtnClick = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditBtnClick");
	var _handleUnlinkBtnClick = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleUnlinkBtnClick");
	class LinkEditor extends main_core_events.EventEmitter {
	  constructor(options) {
	    super();
	    Object.defineProperty(this, _handleUnlinkBtnClick, {
	      value: _handleUnlinkBtnClick2
	    });
	    Object.defineProperty(this, _handleEditBtnClick, {
	      value: _handleEditBtnClick2
	    });
	    Object.defineProperty(this, _handleCancelBtnClick$2, {
	      value: _handleCancelBtnClick2$2
	    });
	    Object.defineProperty(this, _handleLinkTextBoxKeyDown, {
	      value: _handleLinkTextBoxKeyDown2
	    });
	    Object.defineProperty(this, _handleSaveBtnClick$2, {
	      value: _handleSaveBtnClick2$2
	    });
	    Object.defineProperty(this, _popup$3, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _editMode, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _autoLinkMode, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _linkUrl, {
	      writable: true,
	      value: ''
	    });
	    Object.defineProperty(this, _targetContainer$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _refs$6, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    this.setEventNamespace('BX.UI.TextEditor.LinkEditor');
	    const linkEditorOptions = main_core.Type.isPlainObject(options) ? options : {};
	    this.setTargetContainer(linkEditorOptions.targetContainer);
	    this.setLinkUrl(linkEditorOptions.linkUrl);
	    if (main_core.Type.isBoolean(linkEditorOptions.editMode)) {
	      this.setEditMode(linkEditorOptions.editMode);
	    } else {
	      this.setEditMode(babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl] === '');
	    }
	    this.setAutoLinkMode(options.autoLinkMode);
	    this.subscribeFromOptions(linkEditorOptions.events);
	  }
	  show(options = {}) {
	    var _options$target;
	    const target = (_options$target = options.target) != null ? _options$target : undefined;
	    const targetOptions = main_core.Type.isPlainObject(options.targetOptions) ? options.targetOptions : {};
	    if (!main_core.Type.isUndefined(target)) {
	      this.getPopup().setBindElement(target);
	    }
	    this.getPopup().adjustPosition({
	      ...targetOptions,
	      forceBindPosition: true
	    });
	    this.getPopup().show();
	  }
	  isShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3] !== null && babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3].isShown();
	  }
	  hide() {
	    this.getPopup().close();
	  }
	  destroy() {
	    this.getPopup().destroy();
	  }
	  setAutoLinkMode(autoLinkMode = true) {
	    if (autoLinkMode === babelHelpers.classPrivateFieldLooseBase(this, _autoLinkMode)[_autoLinkMode]) {
	      return;
	    }
	    if (autoLinkMode) {
	      main_core.Dom.addClass(this.getContainer(), '--auto-link-mode');
	    } else {
	      main_core.Dom.removeClass(this.getContainer(), '--auto-link-mode');
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3].adjustPosition();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _autoLinkMode)[_autoLinkMode] = autoLinkMode;
	  }
	  setEditMode(editMode = true) {
	    if (editMode === babelHelpers.classPrivateFieldLooseBase(this, _editMode)[_editMode]) {
	      return;
	    }
	    if (editMode) {
	      main_core.Dom.addClass(this.getContainer(), '--edit-mode');
	    } else {
	      main_core.Dom.removeClass(this.getContainer(), '--edit-mode');
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3].adjustPosition();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _editMode)[_editMode] = editMode;
	  }
	  setLinkUrl(url) {
	    if (main_core.Type.isString(url)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl] = sanitizeUrl(url);
	      this.getLinkTextBox().value = babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl];
	      this.getLinkLabel().textContent = babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl];
	      this.getLinkLabel().href = babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl];
	    }
	  }
	  getLinkUrl() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _linkUrl)[_linkUrl];
	  }
	  setTargetContainer(container) {
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _targetContainer$2)[_targetContainer$2] = container;
	    }
	  }
	  getTargetContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _targetContainer$2)[_targetContainer$2];
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3] = new main_popup.Popup({
	        autoHide: true,
	        cacheable: false,
	        padding: 0,
	        closeByEsc: true,
	        targetContainer: this.getTargetContainer(),
	        content: this.getContainer(),
	        events: {
	          onClose: () => {
	            this.emit('onClose');
	          },
	          onDestroy: () => {
	            this.emit('onDestroy');
	          },
	          onShow: () => {
	            this.emit('onShow');
	          },
	          onAfterShow: () => {
	            if (babelHelpers.classPrivateFieldLooseBase(this, _editMode)[_editMode]) {
	              this.getLinkTextBox().focus();
	            }
	          }
	        }
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$3)[_popup$3];
	  }
	  getContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$6)[_refs$6].remember('container', () => {
	      return main_core.Tag.render(_t$9 || (_t$9 = _$9`
				<div class="ui-text-editor-link-editor">
					<div class="ui-text-editor-link-form">
						<div class="ui-ctl ui-ctl-textbox ui-ctl-s ui-ctl-inline ui-ctl-w100 ui-text-editor-link-textbox">
							<div class="ui-ctl-tag">${0}</div>
							${0}
						</div>
						<button type="button" 
							class="ui-text-editor-link-form-button" 
							onclick="${0}"
							data-testid="save-link-btn"
						>
							<span class="ui-icon-set --check"></span>
						</button>
						<button 
							type="button" 
							class="ui-text-editor-link-form-button"
							onclick="${0}"
							data-testid="cancel-link-btn"
						>
							<span class="ui-icon-set --cross-60"></span>
						</button>
					</div>
					<div class="ui-text-editor-link-preview">
						${0}
						<button 
							type="button" 
							class="ui-text-editor-link-form-button"
							onclick="${0}"
							data-testid="edit-link-btn"
						>
							<span class="ui-icon-set --pencil-60"></span>
						</button>
						<button 
							type="button" 
							class="ui-text-editor-link-form-button ui-text-editor-link-form-delete-btn"
							onclick="${0}"
							data-testid="unlink-btn"
						>
							<span class="ui-icon-set --delete-hyperlink"></span>
						</button>
					</div>
				</div>
			`), main_core.Loc.getMessage('TEXT_EDITOR_LINK_URL'), this.getLinkTextBox(), babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick$2)[_handleSaveBtnClick$2].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleCancelBtnClick$2)[_handleCancelBtnClick$2].bind(this), this.getLinkLabel(), babelHelpers.classPrivateFieldLooseBase(this, _handleEditBtnClick)[_handleEditBtnClick].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleUnlinkBtnClick)[_handleUnlinkBtnClick].bind(this));
	    });
	  }
	  getLinkTextBox() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$6)[_refs$6].remember('link-textbox', () => {
	      return main_core.Tag.render(_t2$6 || (_t2$6 = _$9`
				<input 
					type="text"
					class="ui-ctl-element"
					placeholder="https://"
					value="${0}"
					onkeydown="${0}"
					data-testid="link-textbox-input"
				>
			`), this.getLinkUrl(), babelHelpers.classPrivateFieldLooseBase(this, _handleLinkTextBoxKeyDown)[_handleLinkTextBoxKeyDown].bind(this));
	    });
	  }
	  getLinkLabel() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$6)[_refs$6].remember('link-label', () => {
	      return main_core.Tag.render(_t3$1 || (_t3$1 = _$9`
				<a href="" target="_blank" class="ui-text-editor-link-label"></a>
			`));
	    });
	  }
	}
	function _handleSaveBtnClick2$2() {
	  const url = this.getLinkTextBox().value.trim();
	  if (url.length > 0) {
	    this.setLinkUrl(url);
	    this.emit('onSave');
	  } else {
	    this.getLinkTextBox().focus();
	  }
	}
	function _handleLinkTextBoxKeyDown2(event) {
	  if (event.key === 'Enter') {
	    event.preventDefault();
	    babelHelpers.classPrivateFieldLooseBase(this, _handleSaveBtnClick$2)[_handleSaveBtnClick$2]();
	  }
	}
	function _handleCancelBtnClick2$2() {
	  this.emit('onCancel');
	}
	function _handleEditBtnClick2() {
	  this.setEditMode(true);
	  this.getLinkTextBox().focus();
	  this.getLinkTextBox().select();
	}
	function _handleUnlinkBtnClick2() {
	  this.emit('onUnlink');
	}

	function validateUrl(url) {
	  return /^(http:|https:|mailto:|tel:|sms:)/i.test(url);
	}

	/* eslint-disable no-underscore-dangle */
	const INSERT_LINK_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_LINK_DIALOG_COMMAND');
	var _linkEditor = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("linkEditor");
	var _onEditorScroll$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _lastSelection$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastSelection");
	var _registerListeners$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _registerCommands$9 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerToggleLinkCommand = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerToggleLinkCommand");
	var _registerInsertLinkCommand = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerInsertLinkCommand");
	var _restoreSelection$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("restoreSelection");
	var _handleDialogDestroy$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDialogDestroy");
	var _handleEditorScroll$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _registerKeyModifierCommand$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerKeyModifierCommand");
	var _registerPasteCommand = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerPasteCommand");
	var _insertLink = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("insertLink");
	var _isLinkSelected = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("isLinkSelected");
	var _convertAutoLinkToLink = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("convertAutoLinkToLink");
	var _registerComponents$c = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class LinkPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$c, {
	      value: _registerComponents2$c
	    });
	    Object.defineProperty(this, _convertAutoLinkToLink, {
	      value: _convertAutoLinkToLink2
	    });
	    Object.defineProperty(this, _isLinkSelected, {
	      value: _isLinkSelected2
	    });
	    Object.defineProperty(this, _insertLink, {
	      value: _insertLink2
	    });
	    Object.defineProperty(this, _registerPasteCommand, {
	      value: _registerPasteCommand2
	    });
	    Object.defineProperty(this, _registerKeyModifierCommand$1, {
	      value: _registerKeyModifierCommand2$1
	    });
	    Object.defineProperty(this, _handleEditorScroll$3, {
	      value: _handleEditorScroll2$3
	    });
	    Object.defineProperty(this, _handleDialogDestroy$2, {
	      value: _handleDialogDestroy2$2
	    });
	    Object.defineProperty(this, _restoreSelection$2, {
	      value: _restoreSelection2$2
	    });
	    Object.defineProperty(this, _registerInsertLinkCommand, {
	      value: _registerInsertLinkCommand2
	    });
	    Object.defineProperty(this, _registerToggleLinkCommand, {
	      value: _registerToggleLinkCommand2
	    });
	    Object.defineProperty(this, _registerCommands$9, {
	      value: _registerCommands2$9
	    });
	    Object.defineProperty(this, _registerListeners$4, {
	      value: _registerListeners2$4
	    });
	    Object.defineProperty(this, _linkEditor, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll$3, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll$3)[_handleEditorScroll$3].bind(this)
	    });
	    Object.defineProperty(this, _lastSelection$2, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$9)[_registerCommands$9]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$4)[_registerListeners$4]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$c)[_registerComponents$c]();
	  }
	  static getName() {
	    return 'Link';
	  }
	  static getNodes(editor) {
	    return [ui_lexical_link.LinkNode];
	  }
	  importBBCode() {
	    return {
	      url: () => ({
	        conversion: node => {
	          // [url]{url}[/url]
	          // [url={url}]{text}[/url]
	          let url = node.getValue();
	          if (!validateUrl(url)) {
	            url = node.toPlainText();
	            if (!validateUrl(url)) {
	              return {
	                node: null
	              };
	            }
	          }
	          return {
	            node: ui_lexical_link.$createLinkNode(sanitizeUrl(url), {
	              target: '_blank'
	            })
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      link: lexicalNode => {
	        const url = lexicalNode.getURL();
	        const children = lexicalNode.getChildren();
	        const isSimpleText = children.length === 1 && ui_lexical_core.$isTextNode(children[0]) && children[0].getFormat() === 0;
	        const scheme = this.getEditor().getBBCodeScheme();
	        if (isSimpleText && children[0].getTextContent() === url) {
	          return {
	            node: scheme.createElement({
	              name: 'url'
	            })
	          };
	        }
	        return {
	          node: scheme.createElement({
	            name: 'url',
	            value: url
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: ui_lexical_link.LinkNode
	      }],
	      bbcodeMap: {
	        link: 'url'
	      }
	    };
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].destroy();
	    }
	  }
	}
	function _registerListeners2$4() {
	  this.cleanUpRegister(this.getEditor().registerEventListener(ui_lexical_link.LinkNode, 'click', (event, nodeKey) => {
	    const linkNode = ui_lexical_core.$getNodeByKey(nodeKey);
	    if (ui_lexical_link.$isLinkNode(linkNode)) {
	      this.getEditor().dispatchCommand(INSERT_LINK_DIALOG_COMMAND, linkNode);
	    }
	  }));
	}
	function _registerCommands2$9() {
	  this.cleanUpRegister(babelHelpers.classPrivateFieldLooseBase(this, _registerToggleLinkCommand)[_registerToggleLinkCommand](), babelHelpers.classPrivateFieldLooseBase(this, _registerInsertLinkCommand)[_registerInsertLinkCommand](), babelHelpers.classPrivateFieldLooseBase(this, _registerKeyModifierCommand$1)[_registerKeyModifierCommand$1](), babelHelpers.classPrivateFieldLooseBase(this, _registerPasteCommand)[_registerPasteCommand]());
	}
	function _registerToggleLinkCommand2() {
	  return this.getEditor().registerCommand(ui_lexical_link.TOGGLE_LINK_COMMAND, payload => {
	    if (payload === null) {
	      ui_lexical_link.$toggleLink(payload);
	      return true;
	    }
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    let url = null;
	    let originalUrl = null;
	    let attributes = {};
	    if (main_core.Type.isStringFilled(payload)) {
	      url = payload;
	    } else if (main_core.Type.isPlainObject(payload)) {
	      const {
	        target,
	        rel,
	        title
	      } = payload;
	      attributes = {
	        rel,
	        target,
	        title
	      };
	      url = payload.url;
	      originalUrl = payload.originalUrl || null;
	    }
	    if (main_core.Type.isStringFilled(url)) {
	      if (!main_core.Type.isStringFilled(attributes.target)) {
	        attributes.target = '_blank';
	      }
	      if (validateUrl(url)) {
	        if (selection.isCollapsed() && !babelHelpers.classPrivateFieldLooseBase(this, _isLinkSelected)[_isLinkSelected](selection)) {
	          babelHelpers.classPrivateFieldLooseBase(this, _insertLink)[_insertLink](selection, url, attributes, originalUrl);
	        } else {
	          ui_lexical_link.$toggleLink(url, attributes);
	        }
	        return true;
	      }
	      return false;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW);
	}
	function _registerInsertLinkCommand2() {
	  return ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(INSERT_LINK_DIALOG_COMMAND, payload => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) || !this.getEditor().isEditable()) {
	      return false;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$2)[_lastSelection$2] = selection.clone();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].destroy();
	    }
	    let lineNode = null;
	    let linkUrl = null;
	    if (ui_lexical_link.$isLinkNode(payload)) {
	      lineNode = payload;
	      linkUrl = lineNode.getURL();
	    } else {
	      const $isUnformatted = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => {
	        return (node.__flags & UNFORMATTED) !== 0;
	      });
	      if ($isUnformatted) {
	        return false;
	      }
	      const node = getSelectedNode(selection);
	      const linkParent = ui_lexical_utils.$findMatchingParent(node, ui_lexical_link.$isLinkNode);
	      if (linkParent) {
	        lineNode = linkParent;
	        linkUrl = lineNode.getURL();
	        lineNode.select();
	      } else if (ui_lexical_link.$isLinkNode(node)) {
	        lineNode = node;
	        linkUrl = lineNode.getURL();
	        lineNode.select();
	      }
	    }
	    this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND);
	    babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] = new LinkEditor({
	      linkUrl,
	      autoLinkMode: ui_lexical_link.$isAutoLinkNode(lineNode),
	      // for an embedded popup: document.body -> this.getEditor().getScrollerContainer()
	      targetContainer: document.body,
	      events: {
	        onSave: event => {
	          const linkEditor = event.getTarget();
	          let url = linkEditor.getLinkUrl();
	          if (!main_core.Type.isStringFilled(url)) {
	            linkEditor.hide();
	            return;
	          }
	          const protocol = main_core.Validation.isEmail(url) ? 'mailto:' : 'https://';
	          const originalUrl = url;
	          if (!validateUrl(url)) {
	            url = `${protocol}${url}`;
	            linkEditor.setLinkUrl(url);
	          }
	          if (lineNode === null) {
	            this.getEditor().update(() => {
	              babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$2)[_restoreSelection$2]();
	              this.getEditor().dispatchCommand(ui_lexical_link.TOGGLE_LINK_COMMAND, {
	                url,
	                originalUrl,
	                rel: null
	              });
	              linkEditor.setEditMode(false);
	              const currentSelection = ui_lexical_core.$getSelection();
	              if (ui_lexical_core.$isRangeSelection(currentSelection)) {
	                babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$2)[_lastSelection$2] = currentSelection.clone();
	              }
	              if (!ui_lexical_core.$isRangeSelection(currentSelection) || currentSelection.isCollapsed()) {
	                linkEditor.hide();
	              }
	              babelHelpers.classPrivateFieldLooseBase(this, _convertAutoLinkToLink)[_convertAutoLinkToLink](currentSelection);
	            });
	          } else {
	            this.getEditor().update(() => {
	              lineNode.setURL(url);
	              babelHelpers.classPrivateFieldLooseBase(this, _convertAutoLinkToLink)[_convertAutoLinkToLink](ui_lexical_core.$getSelection());
	              linkEditor.setAutoLinkMode(false);
	            });
	            linkEditor.setEditMode(false);
	          }
	          this.getEditor().resetHighlightSelection();
	        },
	        onCancel: event => {
	          const linkEditor = event.getTarget();
	          linkEditor.hide();
	        },
	        onUnlink: event => {
	          if (lineNode === null) {
	            this.getEditor().dispatchCommand(ui_lexical_link.TOGGLE_LINK_COMMAND, null);
	          } else {
	            this.getEditor().update(() => {
	              const children = lineNode.getChildren();
	              for (const child of children) {
	                // eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-dom-methods
	                lineNode.insertBefore(child);
	              }
	              lineNode.remove();
	            });
	          }
	          const linkEditor = event.getTarget();
	          linkEditor.hide();
	        },
	        onShow: () => {
	          if ($adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].getPopup(), this.getEditor())) {
	            main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$3)[_onEditorScroll$3]);
	            this.getEditor().highlightSelection();
	          }
	        },
	        onClose: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy$2)[_handleDialogDestroy$2]();
	        },
	        onDestroy: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _handleDialogDestroy$2)[_handleDialogDestroy$2]();
	        }
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].destroy();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] !== null && babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].isShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _restoreSelection2$2() {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) && babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$2)[_lastSelection$2] !== null) {
	    ui_lexical_core.$setSelection(babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$2)[_lastSelection$2]);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$2)[_lastSelection$2] = null;
	    return true;
	  }
	  return false;
	}
	function _handleDialogDestroy2$2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] = null;
	  main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$3)[_onEditorScroll$3]);
	  this.getEditor().resetHighlightSelection();
	  this.getEditor().update(() => {
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$2)[_restoreSelection$2]()) {
	      this.getEditor().focus();
	    }
	  });
	}
	function _handleEditorScroll2$3() {
	  this.getEditor().update(() => {
	    $adjustDialogPosition(babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].getPopup(), this.getEditor());
	  });
	}
	function _registerKeyModifierCommand2$1() {
	  return this.getEditor().registerCommand(ui_lexical_core.KEY_MODIFIER_COMMAND, payload => {
	    const event = payload;
	    const {
	      code,
	      ctrlKey,
	      metaKey
	    } = event;
	    if (code === 'KeyK' && (ctrlKey || metaKey)) {
	      event.preventDefault();
	      this.getEditor().dispatchCommand(INSERT_LINK_DIALOG_COMMAND);
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_NORMAL);
	}
	function _registerPasteCommand2() {
	  return this.getEditor().registerCommand(ui_lexical_core.PASTE_COMMAND, event => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) || selection.isCollapsed() || !(event instanceof ClipboardEvent) || event.clipboardData === null) {
	      return false;
	    }
	    const clipboardText = event.clipboardData.getData('text');
	    if (!validateUrl(clipboardText)) {
	      return false;
	    }

	    // If we select nodes that are elements then avoid applying the link.
	    if (!selection.getNodes().some(node => ui_lexical_core.$isElementNode(node))) {
	      ui_lexical_link.$toggleLink(clipboardText);
	      event.preventDefault();
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_NORMAL);
	}
	function _insertLink2(selection, url, attributes, originalUrl) {
	  const linkUrl = sanitizeUrl(url);
	  const linkNode = ui_lexical_link.$createLinkNode(linkUrl, attributes);
	  linkNode.append(ui_lexical_core.$createTextNode(main_core.Type.isStringFilled(originalUrl) ? originalUrl : linkUrl));
	  const anchor = selection.anchor;
	  if (anchor.type === 'text' && anchor.getNode().isSimpleText()) {
	    const anchorNode = anchor.getNode();
	    const selectionOffset = anchor.offset;
	    const splitNodes = anchorNode.splitText(selectionOffset);
	    if (selectionOffset === 0) {
	      // eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-dom-methods
	      splitNodes[0].insertBefore(linkNode);
	      linkNode.select();
	    } else {
	      splitNodes[0].insertAfter(linkNode);
	      linkNode.select();
	    }
	  } else {
	    ui_lexical_core.$insertNodes([linkNode]);
	    if (ui_lexical_core.$isRootOrShadowRoot(linkNode.getParentOrThrow())) {
	      ui_lexical_utils.$wrapNodeInElement(linkNode, ui_lexical_core.$createParagraphNode).selectEnd();
	    }
	  }
	}
	function _isLinkSelected2(selection) {
	  const node = getSelectedNode(selection);
	  const parent = node.getParent();
	  return ui_lexical_link.$isLinkNode(parent) || ui_lexical_link.$isLinkNode(node);
	}
	function _convertAutoLinkToLink2(selection) {
	  if (ui_lexical_core.$isRangeSelection(selection)) {
	    const parent = getSelectedNode(selection).getParent();
	    if (ui_lexical_link.$isAutoLinkNode(parent)) {
	      const linkNode = ui_lexical_link.$createLinkNode(parent.getURL(), {
	        rel: parent.getRel(),
	        target: main_core.Type.isStringFilled(parent.getTarget()) ? parent.getTarget() : '_blank',
	        title: parent.getTitle()
	      });
	      parent.replace(linkNode, true);
	      return true;
	    }
	  }
	  return false;
	}
	function _registerComponents2$c() {
	  this.getEditor().getComponentRegistry().register('link', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --link-3"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_LINK'));
	    button.setBlockType('link');
	    button.disableInsideUnformatted();
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_LINK', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘K' : 'Ctrl+K'
	    }));
	    button.subscribe('onClick', () => {
	      if (babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor] !== null && babelHelpers.classPrivateFieldLooseBase(this, _linkEditor)[_linkEditor].isShown()) {
	        return;
	      }
	      this.getEditor().focus(() => {
	        this.getEditor().dispatchCommand(INSERT_LINK_DIALOG_COMMAND);
	      });
	    });
	    return button;
	  });
	}



	var Link = /*#__PURE__*/Object.freeze({
		INSERT_LINK_DIALOG_COMMAND: INSERT_LINK_DIALOG_COMMAND,
		LinkPlugin: LinkPlugin
	});

	const URL_REGEX = /((https?:\/\/(www\.)?)|(www\.))[\w#%+.:=@~-]{1,256}\.[\d()A-Za-z]{1,6}\b([\w#%&()+./:=?@[\]~-]*)(?<![%()+.:\]-])/;
	const EMAIL_REGEX = /(([^\s"(),.:;<>@[\\\]]+(\.[^\s"(),.:;<>@[\\\]]+)*)|(".+"))@((\[(?:\d{1,3}\.){3}\d{1,3}])|(([\dA-Za-z-]+\.)+[A-Za-z]{2,}))/;
	const MATCHERS = [createLinkMatcherWithRegExp(URL_REGEX, text => {
	  return text.startsWith('http') ? text : `https://${text}`;
	}), createLinkMatcherWithRegExp(EMAIL_REGEX, text => {
	  return `mailto:${text}`;
	})];
	var _registerListeners$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	class AutoLinkPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerListeners$5, {
	      value: _registerListeners2$5
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$5)[_registerListeners$5]();
	  }
	  static getName() {
	    return 'AutoLink';
	  }
	  static getNodes(editor) {
	    return [ui_lexical_link.AutoLinkNode];
	  }
	  exportBBCode() {
	    return {
	      autolink: () => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'url'
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: ui_lexical_link.AutoLinkNode
	      }],
	      bbcodeMap: {
	        autolink: 'url'
	      }
	    };
	  }
	}
	function _registerListeners2$5() {
	  const onChange = (url, prevUrl) => {};
	  this.cleanUpRegister(this.getEditor().registerNodeTransform(ui_lexical_core.TextNode, textNode => {
	    const parent = textNode.getParentOrThrow();
	    const previous = textNode.getPreviousSibling();
	    if (ui_lexical_link.$isAutoLinkNode(parent)) {
	      handleLinkEdit(parent, MATCHERS, onChange);
	    } else if (!ui_lexical_link.$isLinkNode(parent)) {
	      if (textNode.isSimpleText() && (startsWithSeparator(textNode.getTextContent()) || !ui_lexical_link.$isAutoLinkNode(previous))) {
	        handleLinkCreation(textNode, MATCHERS, onChange);
	      }
	      handleBadNeighbors(textNode, MATCHERS, onChange);
	    }
	  }));
	}
	function createLinkMatcherWithRegExp(regExp, urlTransformer = text => text) {
	  return text => {
	    const match = regExp.exec(text);
	    if (match === null) {
	      return null;
	    }
	    return {
	      index: match.index,
	      length: match[0].length,
	      text: match[0],
	      url: urlTransformer(text)
	    };
	  };
	}
	function findFirstMatch(text, matchers) {
	  for (const matcher of matchers) {
	    const match = matcher(text);
	    if (match) {
	      return match;
	    }
	  }
	  return null;
	}
	const PUNCTUATION_OR_SPACE = /[\s(),.;[\]]/;
	function isSeparator(char) {
	  return PUNCTUATION_OR_SPACE.test(char);
	}
	function endsWithSeparator(textContent) {
	  return isSeparator(textContent[textContent.length - 1]);
	}
	function startsWithSeparator(textContent) {
	  return isSeparator(textContent[0]);
	}
	function startsWithFullStop(textContent) {
	  return /^\.[\dA-Za-z]+/.test(textContent);
	}
	function isPreviousNodeValid(node) {
	  let previousNode = node.getPreviousSibling();
	  if (ui_lexical_core.$isElementNode(previousNode)) {
	    previousNode = previousNode.getLastDescendant();
	  }
	  return previousNode === null || ui_lexical_core.$isLineBreakNode(previousNode) || ui_lexical_core.$isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent());
	}
	function isNextNodeValid(node) {
	  let nextNode = node.getNextSibling();
	  if (ui_lexical_core.$isElementNode(nextNode)) {
	    nextNode = nextNode.getFirstDescendant();
	  }
	  return nextNode === null || ui_lexical_core.$isLineBreakNode(nextNode) || ui_lexical_core.$isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent());
	}
	function isContentAroundIsValid(matchStart, matchEnd, text, node) {
	  const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node);
	  if (!contentBeforeIsValid) {
	    return false;
	  }

	  // contentAfterIsValid
	  return matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node);
	}
	function handleLinkCreation(node, matchers, onChange) {
	  const nodeText = node.getTextContent();
	  let text = nodeText;
	  let invalidMatchEnd = 0;
	  let remainingTextNode = node;
	  let match = findFirstMatch(text, matchers);
	  while (match !== null) {
	    const matchStart = match.index;
	    const matchLength = match.length;
	    const matchEnd = matchStart + matchLength;
	    const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, nodeText, node);
	    if (isValid) {
	      let linkTextNode = null;
	      if (invalidMatchEnd + matchStart === 0) {
	        [linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchLength);
	      } else {
	        [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchStart, invalidMatchEnd + matchStart + matchLength);
	      }
	      const attributes = main_core.Type.isPlainObject(match.attributes) ? {
	        ...match.attributes
	      } : {};
	      if (!main_core.Type.isStringFilled(attributes.target)) {
	        attributes.target = '_blank';
	      }
	      const linkNode = ui_lexical_link.$createAutoLinkNode(match.url, attributes);
	      const textNode = ui_lexical_core.$createTextNode(match.text);
	      textNode.setFormat(linkTextNode.getFormat());
	      textNode.setDetail(linkTextNode.getDetail());
	      linkNode.append(textNode);
	      linkTextNode.replace(linkNode);
	      onChange(match.url, null);
	      invalidMatchEnd = 0;
	    } else {
	      invalidMatchEnd += matchEnd;
	    }
	    text = text.slice(Math.max(0, matchEnd));
	    match = findFirstMatch(text, matchers);
	  }
	}
	function handleLinkEdit(linkNode, matchers, onChange) {
	  // Check children are simple text
	  const children = linkNode.getChildren();
	  const childrenLength = children.length;
	  for (let i = 0; i < childrenLength; i++) {
	    const child = children[i];
	    if (!ui_lexical_core.$isTextNode(child) || !child.isSimpleText()) {
	      replaceWithChildren(linkNode);
	      onChange(null, linkNode.getURL());
	      return;
	    }
	  }

	  // Check text content fully matches
	  const text = linkNode.getTextContent();
	  const match = findFirstMatch(text, matchers);
	  if (match === null || match.text !== text) {
	    replaceWithChildren(linkNode);
	    onChange(null, linkNode.getURL());
	    return;
	  }

	  // Check neighbors
	  if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {
	    replaceWithChildren(linkNode);
	    onChange(null, linkNode.getURL());
	    return;
	  }
	  const url = linkNode.getURL();
	  if (url !== match.url) {
	    linkNode.setURL(match.url);
	    onChange(match.url, url);
	  }
	  if (match.attributes) {
	    const rel = linkNode.getRel();
	    if (rel !== match.attributes.rel) {
	      linkNode.setRel(match.attributes.rel || null);
	      onChange(match.attributes.rel || null, rel);
	    }
	    const target = linkNode.getTarget();
	    if (target !== match.attributes.target) {
	      linkNode.setTarget(match.attributes.target || null);
	      onChange(match.attributes.target || null, target);
	    }
	  }
	}

	// Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.
	// Given the creation preconditions, these can only be simple text nodes.
	function handleBadNeighbors(textNode, matchers, onChange) {
	  const previousSibling = textNode.getPreviousSibling();
	  const nextSibling = textNode.getNextSibling();
	  const text = textNode.getTextContent();
	  if (ui_lexical_link.$isAutoLinkNode(previousSibling) && (!startsWithSeparator(text) || startsWithFullStop(text))) {
	    previousSibling.append(textNode);
	    handleLinkEdit(previousSibling, matchers, onChange);
	    onChange(null, previousSibling.getURL());
	  }
	  if (ui_lexical_link.$isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {
	    replaceWithChildren(nextSibling);
	    handleLinkEdit(nextSibling, matchers, onChange);
	    onChange(null, nextSibling.getURL());
	  }
	}
	function replaceWithChildren(node) {
	  const children = node.getChildren();
	  const childrenLength = children.length;
	  for (let j = childrenLength - 1; j >= 0; j--) {
	    node.insertAfter(children[j]);
	  }
	  node.remove();
	  return children.map(child => child.getLatest());
	}



	var AutoLink = /*#__PURE__*/Object.freeze({
		AutoLinkPlugin: AutoLinkPlugin
	});

	var _registerListeners$6 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	class TabIndentPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerListeners$6, {
	      value: _registerListeners2$6
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$6)[_registerListeners$6]();
	  }
	  static getName() {
	    return 'TabIndent';
	  }
	}
	function _registerListeners2$6() {
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_core.KEY_TAB_COMMAND, event => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection)) {
	      return false;
	    }
	    return this.getEditor().dispatchCommand(event.shiftKey ? ui_lexical_core.OUTDENT_CONTENT_COMMAND : ui_lexical_core.INDENT_CONTENT_COMMAND, {
	      event,
	      triggerByTab: true
	    });
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR),
	  // Turn off RichText built-in indents
	  this.getEditor().registerCommand(ui_lexical_core.INDENT_CONTENT_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    return !$isSelectionInList(selection);
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.OUTDENT_CONTENT_COMMAND, () => {
	    const selection = ui_lexical_core.$getSelection();
	    return !$isSelectionInList(selection);
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function $isSelectionInList(selection) {
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return false;
	  }
	  const isBackward = selection.isBackward();
	  const firstPoint = isBackward ? selection.focus : selection.anchor;
	  const firstNode = firstPoint.getNode();
	  if (ui_lexical_list.$isListItemNode(firstNode) && firstPoint.offset === 0) {
	    return true;
	  }
	  const parentNode = ui_lexical_utils.$findMatchingParent(firstNode, node => ui_lexical_core.$isElementNode(node) && !node.isInline());
	  return ui_lexical_list.$isListItemNode(parentNode) && firstPoint.offset === 0;
	}



	var TabIndent = /*#__PURE__*/Object.freeze({
		TabIndentPlugin: TabIndentPlugin
	});

	var _registerListeners$7 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _registerComponents$d = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _isIndentPermitted = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("isIndentPermitted");
	var _getElementNodesInSelection = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getElementNodesInSelection");
	class ListPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _getElementNodesInSelection, {
	      value: _getElementNodesInSelection2
	    });
	    Object.defineProperty(this, _isIndentPermitted, {
	      value: _isIndentPermitted2
	    });
	    Object.defineProperty(this, _registerComponents$d, {
	      value: _registerComponents2$d
	    });
	    Object.defineProperty(this, _registerListeners$7, {
	      value: _registerListeners2$7
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$7)[_registerListeners$7]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$d)[_registerComponents$d]();
	  }
	  static getName() {
	    return 'List';
	  }
	  static getNodes(editor) {
	    return [ui_lexical_list.ListNode, ui_lexical_list.ListItemNode];
	  }
	  importBBCode() {
	    return {
	      list: () => ({
	        conversion: node => {
	          return {
	            node: node.getValue() === '1' ? ui_lexical_list.$createListNode('number', 1) : ui_lexical_list.$createListNode('bullet')
	            // after: (childLexicalNodes: Array<LexicalNode>): Array<LexicalNode> => {
	            // 	const normalizedListItems: Array<ListItemNode> = [];
	            // 	for (const node of childLexicalNodes)
	            // 	{
	            // 		if ($isListItemNode(node))
	            // 		{
	            // 			normalizedListItems.push(node);
	            // 			const children = node.getChildren();
	            // 			if (children.length > 1)
	            // 			{
	            // 				children.forEach((child) => {
	            // 					if ($isListNode(child))
	            // 					{
	            // 						normalizedListItems.push(this.#wrapInListItem(child));
	            // 					}
	            // 				});
	            // 			}
	            // 		}
	            // 		else
	            // 		{
	            // 			normalizedListItems.push(this.#wrapInListItem(node));
	            // 		}
	            // 	}
	            //
	            // 	return normalizedListItems;
	            // },
	          };
	        },

	        priority: 0
	      }),
	      '*': () => ({
	        conversion: node => {
	          return {
	            node: ui_lexical_list.$createListItemNode()
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      list: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        const node = scheme.createElement({
	          name: 'list'
	        });
	        if (lexicalNode.getListType() === 'number') {
	          node.setValue('1');
	        }
	        return {
	          node
	        };
	      },
	      listitem: lexicalNode => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: '*'
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: ui_lexical_list.ListNode
	      }],
	      bbcodeMap: {
	        list: 'list',
	        listitem: '*'
	      }
	    };
	  }

	  // static #wrapInListItem(node: LexicalNode): ListItemNode
	  // {
	  // 	const listItemWrapper = $createListItemNode();
	  //
	  // 	return listItemWrapper.append(node);
	  // }
	}
	function _registerListeners2$7() {
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_list.INSERT_ORDERED_LIST_COMMAND, () => {
	    ui_lexical_list.insertList(this.getLexicalEditor(), 'number');
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_list.INSERT_UNORDERED_LIST_COMMAND, () => {
	    ui_lexical_list.insertList(this.getLexicalEditor(), 'bullet');
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_list.REMOVE_LIST_COMMAND, () => {
	    ui_lexical_list.removeList(this.getLexicalEditor());
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.INSERT_PARAGRAPH_COMMAND, () => {
	    return ui_lexical_list.$handleListInsertParagraph();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.INDENT_CONTENT_COMMAND, () => !babelHelpers.classPrivateFieldLooseBase(this, _isIndentPermitted)[_isIndentPermitted](1), ui_lexical_core.COMMAND_PRIORITY_CRITICAL));
	}
	function _registerComponents2$d() {
	  this.getEditor().getComponentRegistry().register('bulleted-list', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --bulleted-list"></span>');
	    button.setBlockType('bullet');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_BULLETED_LIST'));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        if (button.isActive()) {
	          this.getEditor().dispatchCommand(ui_lexical_list.REMOVE_LIST_COMMAND);
	        } else {
	          this.getEditor().dispatchCommand(ui_lexical_list.INSERT_UNORDERED_LIST_COMMAND);
	        }
	      });
	    });
	    return button;
	  });
	  this.getEditor().getComponentRegistry().register('numbered-list', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --numbered-list"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_NUMBERED_LIST'));
	    button.setBlockType('number');
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      this.getEditor().update(() => {
	        if (button.isActive()) {
	          this.getEditor().dispatchCommand(ui_lexical_list.REMOVE_LIST_COMMAND);
	        } else {
	          this.getEditor().dispatchCommand(ui_lexical_list.INSERT_ORDERED_LIST_COMMAND);
	        }
	      });
	    });
	    return button;
	  });
	}
	function _isIndentPermitted2(maxDepth) {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection)) {
	    return false;
	  }
	  const elementNodesInSelection = babelHelpers.classPrivateFieldLooseBase(this, _getElementNodesInSelection)[_getElementNodesInSelection](selection);
	  let totalDepth = 0;
	  for (const elementNode of elementNodesInSelection) {
	    if (ui_lexical_list.$isListNode(elementNode)) {
	      totalDepth = Math.max(ui_lexical_list.$getListDepth(elementNode) + 1, totalDepth);
	    } else if (ui_lexical_list.$isListItemNode(elementNode)) {
	      const parent = elementNode.getParent();
	      if (!ui_lexical_list.$isListNode(parent)) {
	        throw new Error('TextEditor: A ListItemNode must have a ListNode for a parent.');
	      }
	      totalDepth = Math.max(ui_lexical_list.$getListDepth(parent) + 1, totalDepth);
	    }
	  }
	  return totalDepth <= maxDepth;
	}
	function _getElementNodesInSelection2(selection) {
	  const nodesInSelection = selection.getNodes();
	  const predicate = node => ui_lexical_core.$isElementNode(node) && !node.isInline();
	  if (nodesInSelection.length === 0) {
	    return new Set([ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), predicate), ui_lexical_utils.$findMatchingParent(selection.focus.getNode(), predicate)]);
	  }
	  return new Set(nodesInSelection.map(n => ui_lexical_core.$isElementNode(n) ? n : ui_lexical_utils.$findMatchingParent(n, predicate)));
	}



	var List = /*#__PURE__*/Object.freeze({
		ListPlugin: ListPlugin
	});

	let _$a = t => t,
	  _t$a,
	  _t2$7,
	  _t3$2,
	  _t4;
	var _popup$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _targetNode$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetNode");
	var _refs$7 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _lastSelectedBox = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastSelectedBox");
	var _handleMouseMove = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleMouseMove");
	var _handleClick$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleClick");
	var _highlightBoxes = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("highlightBoxes");
	class TableDialog extends main_core_events.EventEmitter {
	  constructor(dialogOptions) {
	    super();
	    Object.defineProperty(this, _highlightBoxes, {
	      value: _highlightBoxes2
	    });
	    Object.defineProperty(this, _handleClick$1, {
	      value: _handleClick2$1
	    });
	    Object.defineProperty(this, _handleMouseMove, {
	      value: _handleMouseMove2
	    });
	    Object.defineProperty(this, _popup$4, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _targetNode$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _refs$7, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _lastSelectedBox, {
	      writable: true,
	      value: null
	    });
	    this.setEventNamespace('BX.UI.TextEditor.TableDialog');
	    const options = main_core.Type.isPlainObject(dialogOptions) ? dialogOptions : {};
	    this.setTargetNode(options.targetNode);
	    this.subscribeFromOptions(options.events);
	  }
	  show() {
	    this.getPopup().adjustPosition({
	      forceBindPosition: true
	    });
	    this.getPopup().show();
	  }
	  hide() {
	    this.getPopup().close();
	  }
	  isShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$4)[_popup$4] !== null && babelHelpers.classPrivateFieldLooseBase(this, _popup$4)[_popup$4].isShown();
	  }
	  destroy() {
	    this.getPopup().destroy();
	  }
	  setTargetNode(container) {
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _targetNode$1)[_targetNode$1] = container;
	    }
	  }
	  getTargetNode() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _targetNode$1)[_targetNode$1];
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$4)[_popup$4] === null) {
	      const targetNode = this.getTargetNode();
	      const rect = targetNode.getBoundingClientRect();
	      const targetNodeWidth = rect.width;
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$4)[_popup$4] = new main_popup.Popup({
	        autoHide: true,
	        closeByEsc: true,
	        padding: 0,
	        content: main_core.Tag.render(_t$a || (_t$a = _$a`
					<div class="ui-text-editor-table-dialog" onclick="${0}">
						${0}
						${0}
					</div>
				`), babelHelpers.classPrivateFieldLooseBase(this, _handleClick$1)[_handleClick$1].bind(this), this.getGridContainer(), this.getCaptionContainer()),
	        bindElement: this.getTargetNode(),
	        events: {
	          onClose: () => {
	            this.emit('onClose');
	          },
	          onDestroy: () => {
	            this.emit('onDestroy');
	          },
	          onShow: event => {
	            const popup = event.getTarget();
	            const popupWidth = popup.getPopupContainer().offsetWidth;
	            const offsetLeft = targetNodeWidth / 2 - popupWidth / 2;
	            const angleShift = main_popup.Popup.getOption('angleLeftOffset') - main_popup.Popup.getOption('angleMinTop');
	            popup.setAngle({
	              offset: popupWidth / 2 - angleShift
	            });
	            popup.setOffset({
	              offsetLeft: offsetLeft + main_popup.Popup.getOption('angleLeftOffset')
	            });
	            babelHelpers.classPrivateFieldLooseBase(this, _lastSelectedBox)[_lastSelectedBox] = null;
	            babelHelpers.classPrivateFieldLooseBase(this, _highlightBoxes)[_highlightBoxes](1, 1);
	          }
	        }
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$4)[_popup$4];
	  }
	  getGridContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$7)[_refs$7].remember('grid', () => {
	      const buttons = [];
	      for (let index = 0; index < 100; index++) {
	        const row = Math.floor(index / 10);
	        const column = index % 10;
	        buttons.push(main_core.Tag.render(_t2$7 || (_t2$7 = _$a`
					<button
						class="ui-text-editor-table-dialog-box"
						data-column="${0}"
						data-row="${0}"
					></button>
				`), column + 1, row + 1));
	      }
	      return main_core.Tag.render(_t3$2 || (_t3$2 = _$a`
				<div 
					class="ui-text-editor-table-dialog-grid" 
					onmousemove="${0}"
				>${0}</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _handleMouseMove)[_handleMouseMove].bind(this), buttons);
	    });
	  }
	  getCaptionContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$7)[_refs$7].remember('caption', () => {
	      return main_core.Tag.render(_t4 || (_t4 = _$a`<div class="ui-text-editor-table-dialog-caption"></div>`));
	    });
	  }
	}
	function _handleMouseMove2(event) {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _lastSelectedBox)[_lastSelectedBox] !== event.target && main_core.Dom.hasClass(event.target, 'ui-text-editor-table-dialog-box')) {
	    const {
	      row,
	      column
	    } = event.target.dataset;
	    babelHelpers.classPrivateFieldLooseBase(this, _highlightBoxes)[_highlightBoxes](row, column);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelectedBox)[_lastSelectedBox] = event.target;
	  }
	}
	function _handleClick2$1(event) {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _lastSelectedBox)[_lastSelectedBox]) {
	    const {
	      row,
	      column
	    } = babelHelpers.classPrivateFieldLooseBase(this, _lastSelectedBox)[_lastSelectedBox].dataset;
	    this.emit('onSelect', {
	      rows: row,
	      columns: column
	    });
	  }
	}
	function _highlightBoxes2(rows, columns) {
	  let index = 0;
	  for (const box of this.getGridContainer().children) {
	    const boxRow = Math.floor(index / 10);
	    const boxColumn = index % 10;
	    const selected = boxRow < rows && boxColumn < columns;
	    if (selected) {
	      main_core.Dom.addClass(box, '--selected');
	    } else {
	      main_core.Dom.removeClass(box, '--selected');
	    }
	    index++;
	  }
	  this.getCaptionContainer().textContent = rows && columns ? `${rows} x ${columns}` : '';
	}

	/* eslint-disable @bitrix24/bitrix24-rules/no-native-dom-methods */
	const INSERT_TABLE_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_TABLE_DIALOG_COMMAND');
	var _tableDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("tableDialog");
	var _registerComponents$e = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _registerCommands$a = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _registerListeners$8 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	class TablePlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerListeners$8, {
	      value: _registerListeners2$8
	    });
	    Object.defineProperty(this, _registerCommands$a, {
	      value: _registerCommands2$a
	    });
	    Object.defineProperty(this, _registerComponents$e, {
	      value: _registerComponents2$e
	    });
	    Object.defineProperty(this, _tableDialog, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$a)[_registerCommands$a]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$8)[_registerListeners$8]();
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$e)[_registerComponents$e]();
	  }
	  static getName() {
	    return 'Table';
	  }
	  static getNodes(editor) {
	    return [ui_lexical_table.TableNode, ui_lexical_table.TableCellNode, ui_lexical_table.TableRowNode];
	  }
	  importBBCode() {
	    return {
	      table: () => ({
	        conversion: node => {
	          return {
	            node: ui_lexical_table.$createTableNode()
	          };
	        },
	        priority: 0
	      }),
	      tr: () => ({
	        conversion: node => {
	          return {
	            node: ui_lexical_table.$createTableRowNode()
	          };
	        },
	        priority: 0
	      }),
	      td: () => ({
	        conversion: node => {
	          return {
	            node: ui_lexical_table.$createTableCellNode(),
	            after: childLexicalNodes => {
	              return $normalizeTextNodes(childLexicalNodes);
	            }
	          };
	        },
	        priority: 0
	      }),
	      th: () => ({
	        conversion: node => {
	          return {
	            node: ui_lexical_table.$createTableCellNode(ui_lexical_table.TableCellHeaderStates.ROW),
	            after: childLexicalNodes => {
	              return $normalizeTextNodes(childLexicalNodes);
	            }
	          };
	        },
	        priority: 0
	      })
	    };
	  }
	  exportBBCode() {
	    return {
	      table: () => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'table'
	          })
	        };
	      },
	      tablerow: () => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: 'tr'
	          })
	        };
	      },
	      tablecell: node => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createElement({
	            name: node.hasHeader() ? 'th' : 'td'
	          })
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      nodes: [{
	        nodeClass: ui_lexical_table.TableNode,
	        validate: tableNode => {
	          if (tableNode.getChildrenSize() === 0) {
	            tableNode.remove();
	            return true;
	          }
	          return false;
	        }
	      }, {
	        nodeClass: ui_lexical_table.TableCellNode,
	        validate: tableCellNode => {
	          tableCellNode.getChildren().forEach(child => {
	            if (shouldWrapInParagraph(child)) {
	              const paragraph = ui_lexical_core.$createParagraphNode();
	              child.replace(paragraph);
	              paragraph.append(child);
	            }
	          });
	          return false;
	        }
	      }],
	      bbcodeMap: {
	        table: 'table',
	        tablerow: 'tr',
	        tablecell: 'td'
	      }
	    };
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].destroy();
	    }
	  }
	}
	function _registerComponents2$e() {
	  this.getEditor().getComponentRegistry().register('table', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --table-editor"></span>');
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_TABLE'));
	    button.subscribe('onClick', () => {
	      this.getEditor().dispatchCommand(INSERT_TABLE_DIALOG_COMMAND, {
	        targetNode: button.getContainer()
	      });
	    });
	    return button;
	  });
	}
	function _registerCommands2$a() {
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_table.INSERT_TABLE_COMMAND, ({
	    columns,
	    rows
	  }) => {
	    const rowCount = Math.max(1, main_core.Text.toNumber(rows));
	    const columnCount = Math.max(1, main_core.Text.toNumber(columns));
	    const tableNode = ui_lexical_table.$createTableNodeWithDimensions(rowCount, columnCount, false);
	    ui_lexical_utils.$insertNodeToNearestRoot(tableNode);
	    const firstDescendant = tableNode.getFirstDescendant();
	    if (ui_lexical_core.$isTextNode(firstDescendant)) {
	      firstDescendant.select();
	    }
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(INSERT_TABLE_DIALOG_COMMAND, payload => {
	    if (!main_core.Type.isPlainObject(payload) || !main_core.Type.isElementNode(payload.targetNode)) {
	      return false;
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] !== null) {
	      if (babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].getTargetNode() === payload.targetNode) {
	        babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].show();
	        return true;
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].destroy();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] = new TableDialog({
	      targetNode: payload.targetNode,
	      events: {
	        onSelect: event => {
	          this.getEditor().dispatchCommand(ui_lexical_table.INSERT_TABLE_COMMAND, event.getData());
	          babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].hide();
	        },
	        onDestroy: () => {
	          babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] = null;
	        }
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].hide();
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog] !== null && babelHelpers.classPrivateFieldLooseBase(this, _tableDialog)[_tableDialog].isShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _registerListeners2$8() {
	  const tableSelections = new Map();
	  const initializeTableNode = tableNode => {
	    const nodeKey = tableNode.getKey();
	    const tableElement = this.getEditor().getElementByKey(nodeKey);
	    if (tableElement && !tableSelections.has(nodeKey)) {
	      const tableSelection = ui_lexical_table.applyTableHandlers(tableNode, tableElement, this.getLexicalEditor(), true);
	      tableSelections.set(nodeKey, tableSelection);
	    }
	  };
	  this.cleanUpRegister(this.getEditor().registerMutationListener(ui_lexical_table.TableNode, nodeMutations => {
	    for (const [nodeKey, mutation] of nodeMutations) {
	      if (mutation === 'created') {
	        this.getEditor().getEditorState().read(() => {
	          const tableNode = ui_lexical_core.$getNodeByKey(nodeKey);
	          if (ui_lexical_table.$isTableNode(tableNode)) {
	            initializeTableNode(tableNode);
	          }
	        });
	      } else if (mutation === 'destroyed') {
	        const tableSelection = tableSelections.get(nodeKey);
	        if (tableSelection !== undefined) {
	          tableSelection.removeListeners();
	          tableSelections.delete(nodeKey);
	        }
	      }
	    }
	  }));
	}



	var Table = /*#__PURE__*/Object.freeze({
		INSERT_TABLE_DIALOG_COMMAND: INSERT_TABLE_DIALOG_COMMAND,
		TablePlugin: TablePlugin
	});

	/* eslint-disable no-underscore-dangle */
	class HashtagNode extends ui_lexical_core.TextNode {
	  static getType() {
	    return 'hashtag';
	  }
	  static clone(node) {
	    return new HashtagNode(node.__text, node.__key);
	  }
	  constructor(text, key) {
	    super(text, key);
	  }
	  createDOM(config) {
	    var _config$theme;
	    const element = super.createDOM(config);
	    if (main_core.Type.isStringFilled(config == null ? void 0 : (_config$theme = config.theme) == null ? void 0 : _config$theme.hashtag)) {
	      main_core.Dom.addClass(element, config.theme.hashtag);
	    }
	    return element;
	  }
	  static importJSON(serializedNode) {
	    const node = $createHashtagNode(serializedNode.text);
	    node.setFormat(serializedNode.format);
	    node.setDetail(serializedNode.detail);
	    node.setMode(serializedNode.mode);
	    node.setStyle(serializedNode.style);
	    return node;
	  }
	  exportJSON() {
	    return {
	      ...super.exportJSON(),
	      type: 'hashtag'
	    };
	  }
	  canInsertTextBefore() {
	    return false;
	  }
	  isTextEntity() {
	    return true;
	  }
	}
	function $createHashtagNode(text = '') {
	  return ui_lexical_core.$applyNodeReplacement(new HashtagNode(text));
	}
	function $isHashtagNode(node) {
	  return node instanceof HashtagNode;
	}

	var _registerListeners$9 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	class HashtagPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerListeners$9, {
	      value: _registerListeners2$9
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$9)[_registerListeners$9]();
	  }
	  static getName() {
	    return 'Hashtag';
	  }
	  static getNodes(editor) {
	    return [HashtagNode];
	  }
	  importBBCode() {
	    return null;
	  }
	  exportBBCode() {
	    return {
	      hashtag: (lexicalNode, node) => {
	        const scheme = this.getEditor().getBBCodeScheme();
	        return {
	          node: scheme.createText(lexicalNode.getTextContent())
	        };
	      }
	    };
	  }
	  validateScheme() {
	    return {
	      bbcodeMap: {
	        hashtag: '#text'
	      }
	    };
	  }
	}
	function _registerListeners2$9() {
	  const createHashtagNode = textNode => {
	    return $createHashtagNode(textNode.getTextContent());
	  };
	  const getHashtagMatch = text => {
	    const match = /(?<=\s+|^)#([^\s,.<>[\]]+)/is.exec(text);
	    if (match === null) {
	      return null;
	    }
	    const hashtagLength = match[0].length;
	    const startOffset = match.index;
	    const endOffset = startOffset + hashtagLength;
	    return {
	      end: endOffset,
	      start: startOffset
	    };
	  };
	  this.cleanUpRegister(...ui_lexical_text.registerLexicalTextEntity(this.getLexicalEditor(), getHashtagMatch, HashtagNode, createHashtagNode));
	}



	var Hashtag = /*#__PURE__*/Object.freeze({
		HashtagNode: HashtagNode,
		$createHashtagNode: $createHashtagNode,
		$isHashtagNode: $isHashtagNode,
		HashtagPlugin: HashtagPlugin
	});

	function $createNodesFromText(text) {
	  if (!main_core.Type.isStringFilled(text)) {
	    return [];
	  }
	  const nodes = [];
	  const parts = text.split(/(\r?\n|\t)/);
	  const length = parts.length;
	  for (let i = 0; i < length; i++) {
	    const part = parts[i];
	    if (part === '\n' || part === '\r\n') {
	      nodes.push(ui_lexical_core.$createLineBreakNode());
	    } else if (part === '\t') {
	      nodes.push(ui_lexical_core.$createTabNode());
	    } else {
	      nodes.push(ui_lexical_core.$createTextNode(part));
	    }
	  }
	  return nodes;
	}

	let _$b = t => t,
	  _t$b;
	const INSERT_COPILOT_DIALOG_COMMAND = ui_lexical_core.createCommand('INSERT_COPILOT_DIALOG_COMMAND');
	const CopilotStatus = {
	  INIT: 'init',
	  LOADING: 'loading',
	  LOADED: 'loaded'
	};
	var _copilot = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("copilot");
	var _copilotStatus = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("copilotStatus");
	var _copilotOptions = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("copilotOptions");
	var _targetParagraph = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("targetParagraph");
	var _lastSelection$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastSelection");
	var _onEditorScroll$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _triggerBySpace = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("triggerBySpace");
	var _registerListeners$a = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _registerParagraphNodeTransform = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerParagraphNodeTransform");
	var _registerComponents$f = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	var _show = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("show");
	var _hide = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("hide");
	var _createCopilot = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("createCopilot");
	var _resetLoader = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("resetLoader");
	var _adjustDialogPosition$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("adjustDialogPosition");
	var _handleEditorScroll$4 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _restoreSelection$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("restoreSelection");
	var _handleCopilotSave = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCopilotSave");
	var _handleCopilotAddBelow = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCopilotAddBelow");
	var _handleCopilotHide = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCopilotHide");
	class CopilotPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _handleCopilotHide, {
	      value: _handleCopilotHide2
	    });
	    Object.defineProperty(this, _handleCopilotAddBelow, {
	      value: _handleCopilotAddBelow2
	    });
	    Object.defineProperty(this, _handleCopilotSave, {
	      value: _handleCopilotSave2
	    });
	    Object.defineProperty(this, _restoreSelection$3, {
	      value: _restoreSelection2$3
	    });
	    Object.defineProperty(this, _handleEditorScroll$4, {
	      value: _handleEditorScroll2$4
	    });
	    Object.defineProperty(this, _adjustDialogPosition$1, {
	      value: _adjustDialogPosition2$1
	    });
	    Object.defineProperty(this, _resetLoader, {
	      value: _resetLoader2
	    });
	    Object.defineProperty(this, _createCopilot, {
	      value: _createCopilot2
	    });
	    Object.defineProperty(this, _hide, {
	      value: _hide2
	    });
	    Object.defineProperty(this, _show, {
	      value: _show2
	    });
	    Object.defineProperty(this, _registerComponents$f, {
	      value: _registerComponents2$f
	    });
	    Object.defineProperty(this, _registerParagraphNodeTransform, {
	      value: _registerParagraphNodeTransform2
	    });
	    Object.defineProperty(this, _registerListeners$a, {
	      value: _registerListeners2$a
	    });
	    Object.defineProperty(this, _copilot, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _copilotStatus, {
	      writable: true,
	      value: CopilotStatus.INIT
	    });
	    Object.defineProperty(this, _copilotOptions, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _targetParagraph, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _lastSelection$3, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll$4, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll$4)[_handleEditorScroll$4].bind(this)
	    });
	    Object.defineProperty(this, _triggerBySpace, {
	      writable: true,
	      value: false
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _copilotOptions)[_copilotOptions] = editor.getOption('copilot.copilotOptions');
	    if (main_core.Type.isPlainObject(babelHelpers.classPrivateFieldLooseBase(this, _copilotOptions)[_copilotOptions])) {
	      babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$a)[_registerListeners$a]();
	      babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$f)[_registerComponents$f]();
	    }
	  }
	  static getName() {
	    return 'Copilot';
	  }
	  shouldTriggerBySpace() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _triggerBySpace)[_triggerBySpace];
	  }
	  isCopilotLoaded() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _copilotStatus)[_copilotStatus] === CopilotStatus.LOADED;
	  }
	  isCopilotLoading() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _copilotStatus)[_copilotStatus] === CopilotStatus.LOADING;
	  }
	  isCopilotShown() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot] !== null && babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].isShown();
	  }
	  show({
	    onShow,
	    onError
	  } = {}) {
	    if (this.isCopilotLoaded()) {
	      babelHelpers.classPrivateFieldLooseBase(this, _show)[_show]({
	        onShow
	      });
	    } else if (!this.isCopilotLoading()) {
	      babelHelpers.classPrivateFieldLooseBase(this, _createCopilot)[_createCopilot]().then(() => {
	        babelHelpers.classPrivateFieldLooseBase(this, _show)[_show]({
	          onShow
	        });
	      }).catch(() => {
	        if (main_core.Type.isFunction(onError)) {
	          onError();
	        }
	      });
	    }
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].hide();
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot] = null;
	    }
	  }
	}
	function _registerListeners2$a() {
	  babelHelpers.classPrivateFieldLooseBase(this, _triggerBySpace)[_triggerBySpace] = this.getEditor().getOption('copilot.triggerBySpace', false);
	  this.cleanUpRegister(this.getEditor().registerCommand(INSERT_COPILOT_DIALOG_COMMAND, payload => {
	    const options = main_core.Type.isPlainObject(payload) ? payload : {};
	    this.show(options);
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_EDITOR), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    babelHelpers.classPrivateFieldLooseBase(this, _hide)[_hide]();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(DIALOG_VISIBILITY_COMMAND, () => {
	    return this.isCopilotShown();
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), babelHelpers.classPrivateFieldLooseBase(this, _triggerBySpace)[_triggerBySpace] ? babelHelpers.classPrivateFieldLooseBase(this, _registerParagraphNodeTransform)[_registerParagraphNodeTransform]() : () => {});
	}
	function _registerParagraphNodeTransform2() {
	  return this.getEditor().registerNodeTransform(CustomParagraphNode, node => {
	    if (node.getChildrenSize() !== 1 || !ui_lexical_core.$isRootNode(node.getParent())) {
	      return;
	    }
	    if (!ui_lexical_core.$isTextNode(node.getFirstChild()) || node.getFirstChild().getTextContent() !== ' ') {
	      babelHelpers.classPrivateFieldLooseBase(this, _resetLoader)[_resetLoader]();
	      return;
	    }
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) || !selection.isCollapsed()) {
	      return;
	    }
	    const anchorNode = selection.anchor.getNode();
	    if (anchorNode !== node.getFirstChild()) {
	      return;
	    }
	    if (!this.isCopilotLoaded() && !this.isCopilotLoading()) {
	      babelHelpers.classPrivateFieldLooseBase(this, _resetLoader)[_resetLoader]();
	      babelHelpers.classPrivateFieldLooseBase(this, _targetParagraph)[_targetParagraph] = this.getEditor().getElementByKey(node.getKey());
	      if (babelHelpers.classPrivateFieldLooseBase(this, _targetParagraph)[_targetParagraph]) {
	        main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _targetParagraph)[_targetParagraph], 'ui-text-editor-loading-ellipsis');
	      }
	    }
	    node.getFirstChild().remove();
	    node.select();
	    this.show({
	      onShow: () => babelHelpers.classPrivateFieldLooseBase(this, _resetLoader)[_resetLoader](),
	      onError: () => babelHelpers.classPrivateFieldLooseBase(this, _resetLoader)[_resetLoader]()
	    });
	  });
	}
	function _registerComponents2$f() {
	  this.getEditor().getComponentRegistry().register('copilot', () => {
	    const button = new Button();
	    const copilotIconClass = '--copilot-ai';
	    const refreshIconClass = '--refresh-5 ui-text-editor-copilot-loading';
	    const icon = main_core.Tag.render(_t$b || (_t$b = _$b`
				<span class="ui-icon-set ${0}" style="--ui-icon-set__icon-color: #8e52ec"></span>
			`), copilotIconClass);
	    button.setContent(icon);
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_COPILOT'));
	    button.subscribe('onClick', () => {
	      this.getEditor().focus();
	      if (this.isCopilotLoading()) {
	        return;
	      }
	      const resetRefresh = () => {
	        if (!main_core.Dom.hasClass(icon, copilotIconClass)) {
	          main_core.Dom.removeClass(icon, refreshIconClass);
	          main_core.Dom.addClass(icon, copilotIconClass);
	        }
	      };
	      this.getEditor().dispatchCommand(INSERT_COPILOT_DIALOG_COMMAND, {
	        onShow: resetRefresh,
	        onError: resetRefresh
	      });
	      if (!this.isCopilotLoaded()) {
	        setTimeout(() => {
	          if (!this.isCopilotLoaded()) {
	            main_core.Dom.removeClass(icon, copilotIconClass);
	            main_core.Dom.addClass(icon, refreshIconClass);
	          }
	        }, 500);
	      }
	    });
	    return button;
	  });
	}
	function _show2({
	  onShow
	} = {}) {
	  this.getEditor().update(() => {
	    const selection = ui_lexical_core.$getSelection();
	    if (!ui_lexical_core.$isRangeSelection(selection) || !this.getEditor().isEditable()) {
	      return;
	    }
	    this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND);
	    const selectionText = selection.getTextContent();
	    const editorPosition = main_core.Dom.getPosition(this.getEditor().getScrollerContainer());
	    const width = Math.min(editorPosition.width, 600);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$3)[_lastSelection$3] = selection.clone();
	    const selectedText = selectionText.trim();
	    if (selectedText.length > 0) {
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].setSelectedText(selectedText);
	    } else {
	      const wholeText = ui_lexical_core.$getRoot().getTextContent().trim();
	      if (wholeText.length > 0) {
	        babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].setContext(wholeText);
	      }
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].show({
	      width
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition$1)[_adjustDialogPosition$1]();
	    main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$4)[_onEditorScroll$4]);
	    if (!selection.isCollapsed()) {
	      this.getEditor().highlightSelection();
	    }
	    if (main_core.Type.isFunction(onShow)) {
	      onShow();
	    }
	  });
	}
	function _hide2() {
	  if (this.isCopilotLoaded() && babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].isShown()) {
	    babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].hide();
	  }
	}
	function _createCopilot2() {
	  if (this.isDestroyed()) {
	    return Promise.reject(new Error('Copilot plugin was destroyed.'));
	  }
	  babelHelpers.classPrivateFieldLooseBase(this, _copilotStatus)[_copilotStatus] = CopilotStatus.LOADING;
	  return new Promise((resolve, reject) => {
	    main_core.Runtime.loadExtension('ai.copilot').then(({
	      Copilot,
	      CopilotEvents
	    }) => {
	      if (this.isDestroyed()) {
	        reject(new Error('Copilot plugin was destroyed.'));
	        return;
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot] = new Copilot({
	        showResultInCopilot: true,
	        ...babelHelpers.classPrivateFieldLooseBase(this, _copilotOptions)[_copilotOptions],
	        autoHide: true
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].subscribe(CopilotEvents.FINISH_INIT, () => {
	        if (this.isDestroyed()) {
	          reject(new Error('Copilot plugin was destroyed.'));
	          return;
	        }
	        babelHelpers.classPrivateFieldLooseBase(this, _copilotStatus)[_copilotStatus] = CopilotStatus.LOADED;
	        resolve();
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].subscribe(CopilotEvents.TEXT_SAVE, babelHelpers.classPrivateFieldLooseBase(this, _handleCopilotSave)[_handleCopilotSave].bind(this));
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].subscribe(CopilotEvents.TEXT_PLACE_BELOW, babelHelpers.classPrivateFieldLooseBase(this, _handleCopilotAddBelow)[_handleCopilotAddBelow].bind(this));
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].subscribe(CopilotEvents.HIDE, babelHelpers.classPrivateFieldLooseBase(this, _handleCopilotHide)[_handleCopilotHide].bind(this));
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].init();
	    }).catch(() => {
	      reject();
	    });
	  });
	}
	function _resetLoader2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _targetParagraph)[_targetParagraph]) {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _targetParagraph)[_targetParagraph], 'ui-text-editor-loading-ellipsis');
	  }
	}
	function _adjustDialogPosition2$1() {
	  this.getEditor().update(() => {
	    babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$3)[_restoreSelection$3]();
	    const selectionPosition = $getSelectionPosition(this.getEditor(), ui_lexical_core.$getSelection(), document.body);
	    if (selectionPosition === null) {
	      return;
	    }
	    const {
	      top,
	      left,
	      bottom
	    } = selectionPosition;
	    const scrollerRect = main_core.Dom.getPosition(this.getEditor().getScrollerContainer());
	    const popupWidth = Math.min(scrollerRect.width, 600);
	    let offsetLeft = popupWidth / 2;
	    if (left - offsetLeft < scrollerRect.left) {
	      // Left boundary
	      const overflow = scrollerRect.left - (left - offsetLeft);
	      offsetLeft -= overflow + 16;
	    } else if (scrollerRect.right < left + popupWidth - offsetLeft) {
	      // Right boundary
	      offsetLeft += left + popupWidth - offsetLeft - scrollerRect.right + 16;
	    }
	    if (bottom < scrollerRect.top || top > scrollerRect.bottom) {
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].adjust({
	        hide: true
	      });
	    } else {
	      babelHelpers.classPrivateFieldLooseBase(this, _copilot)[_copilot].adjust({
	        hide: false,
	        position: {
	          left: left - offsetLeft,
	          top: bottom
	        }
	      });
	    }
	  });
	}
	function _handleEditorScroll2$4() {
	  babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition$1)[_adjustDialogPosition$1]();
	}
	function _restoreSelection2$3() {
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) && babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$3)[_lastSelection$3] !== null) {
	    ui_lexical_core.$setSelection(babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$3)[_lastSelection$3]);
	    babelHelpers.classPrivateFieldLooseBase(this, _lastSelection$3)[_lastSelection$3] = null;
	    return true;
	  }
	  return false;
	}
	function _handleCopilotSave2(event) {
	  const {
	    result
	  } = event.getData();
	  this.getEditor().update(() => {
	    babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$3)[_restoreSelection$3]();
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      selection.insertRawText(result);
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _hide)[_hide]();
	  });
	}
	function _handleCopilotAddBelow2(event) {
	  const {
	    result
	  } = event.getData();
	  this.getEditor().update(() => {
	    babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$3)[_restoreSelection$3]();
	    const selection = ui_lexical_core.$getSelection();
	    if (ui_lexical_core.$isRangeSelection(selection)) {
	      const focus = selection.focus;
	      const focusNode = focus.getNode();
	      if (!selection.isCollapsed()) {
	        focusNode.selectEnd();
	      }
	      const parentNode = focusNode.getParent();
	      if (ui_lexical_core.$isParagraphNode(parentNode)) {
	        const paragraph = ui_lexical_core.$createParagraphNode();
	        paragraph.append(...$createNodesFromText(result));
	        parentNode.insertAfter(paragraph);
	      } else {
	        selection.insertLineBreak();
	        selection.insertRawText(result);
	      }
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _hide)[_hide]();
	  });
	}
	function _handleCopilotHide2() {
	  main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$4)[_onEditorScroll$4]);
	  this.getEditor().resetHighlightSelection();
	  this.getEditor().update(() => {
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _restoreSelection$3)[_restoreSelection$3]()) {
	      this.getEditor().focus();
	    }
	  });
	}

	var _registerComponents$g = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerComponents");
	class HistoryPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _registerComponents$g, {
	      value: _registerComponents2$g
	    });
	    const historyState = ui_lexical_history.createEmptyHistoryState();
	    this.cleanUpRegister(ui_lexical_history.registerHistory(editor.getLexicalEditor(), historyState, 1000));
	    babelHelpers.classPrivateFieldLooseBase(this, _registerComponents$g)[_registerComponents$g]();
	  }
	  static getName() {
	    return 'History';
	  }
	}
	function _registerComponents2$g() {
	  let canUndo = false;
	  this.getEditor().getComponentRegistry().register('undo', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --undo"></span>');
	    button.setDisabled(!canUndo);
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_UNDO', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘Z' : 'Ctrl+Z'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().dispatchCommand(ui_lexical_core.UNDO_COMMAND);
	    });
	    button.setDisableCallback(() => {
	      return !canUndo || !this.getEditor().isEditable();
	    });
	    this.getEditor().registerCommand(ui_lexical_core.CAN_UNDO_COMMAND, payload => {
	      canUndo = payload;
	      button.setDisabled(!canUndo);
	      return false;
	    }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL);
	    return button;
	  });
	  let canRedo = false;
	  this.getEditor().getComponentRegistry().register('redo', () => {
	    const button = new Button();
	    button.setContent('<span class="ui-icon-set --redo"></span>');
	    button.setDisabled(!canRedo);
	    button.setTooltip(main_core.Loc.getMessage('TEXT_EDITOR_BTN_REDO', {
	      '#keystroke#': main_core.Browser.isMac() ? '⌘⇧Z' : 'Ctrl+Y'
	    }));
	    button.subscribe('onClick', () => {
	      this.getEditor().dispatchCommand(ui_lexical_core.REDO_COMMAND);
	    });
	    button.setDisableCallback(() => {
	      return !canRedo || !this.getEditor().isEditable();
	    });
	    this.getEditor().registerCommand(ui_lexical_core.CAN_REDO_COMMAND, payload => {
	      canRedo = payload;
	      button.setDisabled(!canRedo);
	      return false;
	    }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL);
	    return button;
	  });
	}



	var History = /*#__PURE__*/Object.freeze({
		HistoryPlugin: HistoryPlugin
	});

	let _$c = t => t,
	  _t$c,
	  _t2$8;
	const Direction$1 = {
	  DOWNWARD: 1,
	  UPWARD: -1,
	  INDETERMINATE: 0
	};
	const DRAG_DATA_FORMAT$1 = 'application/x-ui-text-editor-drag-block';
	var _draggableBlockElement = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("draggableBlockElement");
	var _lastBlockElementIndex = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastBlockElementIndex");
	var _lastTargetElement = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lastTargetElement");
	var _container$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("container");
	var _dropLine = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("dropLine");
	var _isDragging = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("isDragging");
	var _bodyDragDropHandler = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("bodyDragDropHandler");
	var _bodyDragOverHandler = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("bodyDragOverHandler");
	var _registerEvents = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerEvents");
	var _registerListeners$b = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _handleMouseMove$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleMouseMove");
	var _handleMouseLeave = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleMouseLeave");
	var _findBlockElement = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("findBlockElement");
	var _getCurrentIndex = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getCurrentIndex");
	var _updatePosition = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("updatePosition");
	var _setDraggableBlockElement = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("setDraggableBlockElement");
	var _handleDragStart = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDragStart");
	var _handleDragEnd = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDragEnd");
	var _handleDragOver = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDragOver");
	var _handleDragDrop = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleDragDrop");
	var _showDropLine = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("showDropLine");
	var _hideDropLine = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("hideDropLine");
	class BlockToolbarPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _hideDropLine, {
	      value: _hideDropLine2
	    });
	    Object.defineProperty(this, _showDropLine, {
	      value: _showDropLine2
	    });
	    Object.defineProperty(this, _handleDragDrop, {
	      value: _handleDragDrop2
	    });
	    Object.defineProperty(this, _handleDragOver, {
	      value: _handleDragOver2
	    });
	    Object.defineProperty(this, _handleDragEnd, {
	      value: _handleDragEnd2
	    });
	    Object.defineProperty(this, _handleDragStart, {
	      value: _handleDragStart2
	    });
	    Object.defineProperty(this, _setDraggableBlockElement, {
	      value: _setDraggableBlockElement2
	    });
	    Object.defineProperty(this, _updatePosition, {
	      value: _updatePosition2
	    });
	    Object.defineProperty(this, _getCurrentIndex, {
	      value: _getCurrentIndex2
	    });
	    Object.defineProperty(this, _findBlockElement, {
	      value: _findBlockElement2
	    });
	    Object.defineProperty(this, _handleMouseLeave, {
	      value: _handleMouseLeave2
	    });
	    Object.defineProperty(this, _handleMouseMove$1, {
	      value: _handleMouseMove2$1
	    });
	    Object.defineProperty(this, _registerListeners$b, {
	      value: _registerListeners2$b
	    });
	    Object.defineProperty(this, _registerEvents, {
	      value: _registerEvents2
	    });
	    Object.defineProperty(this, _draggableBlockElement, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _lastBlockElementIndex, {
	      writable: true,
	      value: Infinity
	    });
	    Object.defineProperty(this, _lastTargetElement, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _container$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _dropLine, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _isDragging, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _bodyDragDropHandler, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _bodyDragOverHandler, {
	      writable: true,
	      value: null
	    });
	    this.cleanUpRegister(babelHelpers.classPrivateFieldLooseBase(this, _registerEvents)[_registerEvents](), babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$b)[_registerListeners$b]());
	    babelHelpers.classPrivateFieldLooseBase(this, _bodyDragDropHandler)[_bodyDragDropHandler] = event => {
	      this.getEditor().dispatchCommand(ui_lexical_core.DROP_COMMAND, event);
	    };
	    babelHelpers.classPrivateFieldLooseBase(this, _bodyDragOverHandler)[_bodyDragOverHandler] = event => {
	      // prevent default to allow drop
	      event.preventDefault();
	    };
	    main_core.Dom.append(this.getContainer(), this.getEditor().getScrollerContainer());
	    main_core.Dom.append(this.getDropLine(), this.getEditor().getScrollerContainer());
	  }
	  static getName() {
	    return 'BlockToolbar';
	  }
	  getContainer() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _container$2)[_container$2] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _container$2)[_container$2] = main_core.Tag.render(_t$c || (_t$c = _$c`
				<div class="ui-text-editor-block-toolbar">
					<div 
						class="ui-text-editor-block-drag-icon" 
						draggable="true"
						ondragstart="${0}" 
						ondragend="${0}"
					>
						<div 
							class="ui-icon-set --more-points" 
							style="--ui-icon-set__icon-size: 24px; margin-left: -4px"
						></div>
					</div>
				</div>
			`), babelHelpers.classPrivateFieldLooseBase(this, _handleDragStart)[_handleDragStart].bind(this), babelHelpers.classPrivateFieldLooseBase(this, _handleDragEnd)[_handleDragEnd].bind(this));
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _container$2)[_container$2];
	  }
	  getDropLine() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _dropLine)[_dropLine] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _dropLine)[_dropLine] = main_core.Tag.render(_t2$8 || (_t2$8 = _$c`
				<div class="ui-text-editor-block-drop-line"></div>
			`));
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _dropLine)[_dropLine];
	  }
	  destroy() {
	    super.destroy();
	    main_core.Dom.remove(this.getContainer());
	    main_core.Dom.remove(this.getDropLine());
	  }
	}
	function _registerEvents2() {
	  const scroller = this.getEditor().getScrollerContainer();
	  const onMouseMove = babelHelpers.classPrivateFieldLooseBase(this, _handleMouseMove$1)[_handleMouseMove$1].bind(this);
	  const onMouseLeave = babelHelpers.classPrivateFieldLooseBase(this, _handleMouseLeave)[_handleMouseLeave].bind(this);
	  main_core.Event.bind(scroller, 'mousemove', onMouseMove);
	  main_core.Event.bind(scroller, 'mouseleave', onMouseLeave);
	  return () => {
	    main_core.Event.unbind(scroller, 'mousemove', onMouseMove);
	    main_core.Event.unbind(scroller, 'mouseleave', onMouseLeave);
	  };
	}
	function _registerListeners2$b() {
	  return ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(ui_lexical_core.DRAGOVER_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleDragOver)[_handleDragOver].bind(this), ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(ui_lexical_core.DROP_COMMAND, babelHelpers.classPrivateFieldLooseBase(this, _handleDragDrop)[_handleDragDrop].bind(this), ui_lexical_core.COMMAND_PRIORITY_HIGH), this.getEditor().registerTextContentListener(() => {
	    babelHelpers.classPrivateFieldLooseBase(this, _setDraggableBlockElement)[_setDraggableBlockElement](null);
	    babelHelpers.classPrivateFieldLooseBase(this, _updatePosition)[_updatePosition]();
	  }));
	}
	function _handleMouseMove2$1(event) {
	  if (!this.getEditor().isEditable()) {
	    return;
	  }
	  const target = event.target;
	  if (!(target instanceof HTMLElement)) {
	    babelHelpers.classPrivateFieldLooseBase(this, _setDraggableBlockElement)[_setDraggableBlockElement](null);
	    return;
	  }
	  if (target.closest('.ui-text-editor-block-toolbar') !== null) {
	    return;
	  }
	  const element = babelHelpers.classPrivateFieldLooseBase(this, _findBlockElement)[_findBlockElement](event);
	  babelHelpers.classPrivateFieldLooseBase(this, _setDraggableBlockElement)[_setDraggableBlockElement](element);
	}
	function _handleMouseLeave2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _setDraggableBlockElement)[_setDraggableBlockElement](null);
	}
	function _findBlockElement2(event) {
	  const scroller = this.getEditor().getScrollerContainer();
	  const anchorElementRect = scroller.getBoundingClientRect();
	  let blockElem = null;
	  this.getEditor().getEditorState().read(() => {
	    const root = ui_lexical_core.$getRoot();
	    const topLevelNodeKeys = root.getChildrenKeys();
	    let index = babelHelpers.classPrivateFieldLooseBase(this, _getCurrentIndex)[_getCurrentIndex](topLevelNodeKeys.length);
	    let direction = Direction$1.INDETERMINATE;
	    while (index >= 0 && index < topLevelNodeKeys.length) {
	      const key = topLevelNodeKeys[index];
	      const elem = this.getEditor().getElementByKey(key);
	      if (elem === null) {
	        break;
	      }
	      const domRect = elem.getBoundingClientRect();
	      const {
	        marginLeft,
	        marginRight,
	        marginTop,
	        marginBottom
	      } = window.getComputedStyle(elem);
	      const rect = new DOMRect(anchorElementRect.left + parseFloat(marginLeft), domRect.y - parseFloat(marginTop), domRect.width + parseFloat(marginRight), domRect.height + parseFloat(marginBottom));
	      const {
	        x,
	        y
	      } = event;
	      const isOnTopSide = y < rect.top;
	      const isOnBottomSide = y > rect.bottom;
	      const isOnLeftSide = x < rect.left;
	      const isOnRightSide = x > rect.right;
	      const contains = !isOnTopSide && !isOnBottomSide && !isOnLeftSide && !isOnRightSide;
	      if (contains) {
	        blockElem = elem;
	        babelHelpers.classPrivateFieldLooseBase(this, _lastBlockElementIndex)[_lastBlockElementIndex] = index;
	        break;
	      }
	      if (direction === Direction$1.INDETERMINATE) {
	        if (isOnTopSide) {
	          direction = Direction$1.UPWARD;
	        } else if (isOnBottomSide) {
	          direction = Direction$1.DOWNWARD;
	        } else {
	          // stop search block element
	          direction = Infinity;
	        }
	      }
	      index += direction;
	    }
	  });
	  return blockElem;
	}
	function _getCurrentIndex2(keysLength) {
	  if (keysLength === 0) {
	    return Infinity;
	  }
	  if (babelHelpers.classPrivateFieldLooseBase(this, _lastBlockElementIndex)[_lastBlockElementIndex] >= 0 && babelHelpers.classPrivateFieldLooseBase(this, _lastBlockElementIndex)[_lastBlockElementIndex] < keysLength) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lastBlockElementIndex)[_lastBlockElementIndex];
	  }
	  return Math.floor(keysLength / 2);
	}
	function _updatePosition2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement] === null) {
	    main_core.Dom.style(this.getContainer(), {
	      opacity: 0,
	      transform: 'translateY(-10000px)'
	    });
	  } else {
	    // const styles: CSSStyleDeclaration = window.getComputedStyle(this.#draggableBlockElement);
	    // const lineHeight: number = Text.toNumber(styles.lineHeight);
	    // const toolbarHeight: number = this.getContainer().offsetHeight;
	    // const offset = lineHeight > 0 ? (lineHeight - toolbarHeight) / 2 : 3;

	    const offset = main_core.Text.toNumber(main_core.Dom.style(babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement], 'margin-top'));
	    const top = babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement].offsetTop + offset;
	    main_core.Dom.style(this.getContainer(), {
	      opacity: 1,
	      transform: `translateY(${top}px)`
	    });
	  }
	}
	function _setDraggableBlockElement2(element) {
	  const changed = babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement] !== element;
	  babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement] = element;
	  if (changed) {
	    babelHelpers.classPrivateFieldLooseBase(this, _updatePosition)[_updatePosition]();
	  }
	}
	function _handleDragStart2(event) {
	  const dataTransfer = event.dataTransfer;
	  if (!dataTransfer || babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement] === null) {
	    return;
	  }
	  this.getEditor().dispatchCommand(HIDE_DIALOG_COMMAND);
	  dataTransfer.setDragImage(babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement], 0, 0);
	  let nodeKey = '';
	  this.getEditor().update(() => {
	    const node = ui_lexical_core.$getNearestNodeFromDOMNode(babelHelpers.classPrivateFieldLooseBase(this, _draggableBlockElement)[_draggableBlockElement]);
	    if (node) {
	      nodeKey = node.getKey();
	    }
	  });
	  dataTransfer.setData(DRAG_DATA_FORMAT$1, nodeKey);
	  babelHelpers.classPrivateFieldLooseBase(this, _isDragging)[_isDragging] = true;
	  main_core.Event.bind(document.body, 'drop', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragDropHandler)[_bodyDragDropHandler]);
	  main_core.Event.bind(document.body, 'dragover', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragOverHandler)[_bodyDragOverHandler]);
	}
	function _handleDragEnd2(event) {
	  babelHelpers.classPrivateFieldLooseBase(this, _isDragging)[_isDragging] = false;
	  babelHelpers.classPrivateFieldLooseBase(this, _hideDropLine)[_hideDropLine]();
	  main_core.Event.unbind(document.body, 'drop', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragDropHandler)[_bodyDragDropHandler]);
	  main_core.Event.unbind(document.body, 'dragover', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragOverHandler)[_bodyDragOverHandler]);
	}
	function _handleDragOver2(event) {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _isDragging)[_isDragging] === false) {
	    return false;
	  }
	  const hasFiles = event.dataTransfer.types.includes('Files');
	  if (hasFiles || !(event.target instanceof HTMLElement)) {
	    return false;
	  }
	  const targetBlockElement = babelHelpers.classPrivateFieldLooseBase(this, _findBlockElement)[_findBlockElement](event);
	  if (targetBlockElement === null) {
	    return false;
	  }
	  babelHelpers.classPrivateFieldLooseBase(this, _lastTargetElement)[_lastTargetElement] = targetBlockElement;
	  babelHelpers.classPrivateFieldLooseBase(this, _showDropLine)[_showDropLine](targetBlockElement, event);
	  event.preventDefault();
	  return true;
	}
	function _handleDragDrop2(event) {
	  var _event$dataTransfer;
	  if (babelHelpers.classPrivateFieldLooseBase(this, _isDragging)[_isDragging] === false) {
	    return false;
	  }
	  const hasFiles = event.dataTransfer.types.includes('Files');
	  const dragData = ((_event$dataTransfer = event.dataTransfer) == null ? void 0 : _event$dataTransfer.getData(DRAG_DATA_FORMAT$1)) || '';
	  if (hasFiles || !(event.target instanceof HTMLElement) || !main_core.Type.isStringFilled(dragData)) {
	    return false;
	  }
	  const draggedNode = ui_lexical_core.$getNodeByKey(dragData);
	  if (!draggedNode || !(event.target instanceof HTMLElement)) {
	    return false;
	  }
	  const targetBlockElement = babelHelpers.classPrivateFieldLooseBase(this, _findBlockElement)[_findBlockElement](event) || babelHelpers.classPrivateFieldLooseBase(this, _lastTargetElement)[_lastTargetElement];
	  if (!targetBlockElement) {
	    return false;
	  }
	  const targetNode = ui_lexical_core.$getNearestNodeFromDOMNode(targetBlockElement);
	  if (!targetNode) {
	    return false;
	  }
	  main_core.Event.unbind(document.body, 'drop', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragDropHandler)[_bodyDragDropHandler]);
	  main_core.Event.unbind(document.body, 'dragover', babelHelpers.classPrivateFieldLooseBase(this, _bodyDragOverHandler)[_bodyDragOverHandler]);
	  if (targetNode === draggedNode) {
	    return true;
	  }
	  const {
	    top: targetBlockElemTop,
	    height: targetBlockElemHeight
	  } = targetBlockElement.getBoundingClientRect();
	  const shouldInsertAfter = event.clientY - targetBlockElemTop > targetBlockElemHeight / 2;
	  if (shouldInsertAfter) {
	    targetNode.insertAfter(draggedNode);
	  } else {
	    // eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-dom-methods
	    targetNode.insertBefore(draggedNode);
	  }
	  babelHelpers.classPrivateFieldLooseBase(this, _setDraggableBlockElement)[_setDraggableBlockElement](null);
	  return true;
	}
	function _showDropLine2(targetBlockElement, event) {
	  const {
	    top: targetBlockElemTop,
	    height: targetBlockElemHeight
	  } = targetBlockElement.getBoundingClientRect();
	  const targetStyle = window.getComputedStyle(targetBlockElement);
	  const relativePosition = main_core.Dom.getRelativePosition(targetBlockElement, targetBlockElement.offsetParent);
	  let lineTop = relativePosition.top;
	  const showAtBottom = event.clientY - targetBlockElemTop > targetBlockElemHeight / 2;
	  if (showAtBottom) {
	    lineTop += targetBlockElemHeight + parseFloat(targetStyle.marginBottom) * 1.5;
	  } else {
	    lineTop += parseFloat(targetStyle.marginTop) / 2;
	  }
	  const DROP_LINE_HALF_HEIGHT = 2;
	  const CONTENT_EDITABLE_AREA_PADDING = 16;
	  const top = lineTop - DROP_LINE_HALF_HEIGHT;
	  main_core.Dom.style(this.getDropLine(), {
	    opacity: 0.4,
	    left: `${CONTENT_EDITABLE_AREA_PADDING}px`,
	    right: `${CONTENT_EDITABLE_AREA_PADDING}px`,
	    transform: `translateY(${top}px)`
	  });
	}
	function _hideDropLine2() {
	  main_core.Dom.style(this.getDropLine(), {
	    opacity: 0,
	    transform: 'translate(-10000px, -10000px)'
	  });
	}



	var BlockToolbar = /*#__PURE__*/Object.freeze({
		BlockToolbarPlugin: BlockToolbarPlugin
	});

	let _$d = t => t,
	  _t$d;
	var _container$3 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("container");
	class Separator extends ToolbarItem {
	  constructor(...args) {
	    super(...args);
	    Object.defineProperty(this, _container$3, {
	      writable: true,
	      value: null
	    });
	  }
	  getContainer() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _container$3)[_container$3] === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _container$3)[_container$3] = main_core.Tag.render(_t$d || (_t$d = _$d`<span class="ui-text-editor-toolbar-separator"></span>`));
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _container$3)[_container$3];
	  }
	  render() {
	    return this.getContainer();
	  }
	}

	let _$e = t => t,
	  _t$e,
	  _t2$9,
	  _t3$3;
	var _textEditor$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("textEditor");
	var _items = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("items");
	var _rendered = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("rendered");
	var _moreBtn = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("moreBtn");
	var _refs$8 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _resizeObserver = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("resizeObserver");
	var _timeoutId$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("timeoutId");
	var _removeListeners$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("removeListeners");
	var _registerListeners$c = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _fillFromOptions = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("fillFromOptions");
	var _handleResize$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleResize");
	var _getSelectionBlockTypes = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getSelectionBlockTypes");
	var _getBlockType = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("getBlockType");
	class Toolbar {
	  constructor(textEditor, _options) {
	    Object.defineProperty(this, _getBlockType, {
	      value: _getBlockType2
	    });
	    Object.defineProperty(this, _getSelectionBlockTypes, {
	      value: _getSelectionBlockTypes2
	    });
	    Object.defineProperty(this, _handleResize$2, {
	      value: _handleResize2$2
	    });
	    Object.defineProperty(this, _fillFromOptions, {
	      value: _fillFromOptions2
	    });
	    Object.defineProperty(this, _registerListeners$c, {
	      value: _registerListeners2$c
	    });
	    Object.defineProperty(this, _textEditor$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _items, {
	      writable: true,
	      value: []
	    });
	    Object.defineProperty(this, _rendered, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _moreBtn, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _refs$8, {
	      writable: true,
	      value: new main_core_cache.MemoryCache()
	    });
	    Object.defineProperty(this, _resizeObserver, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _timeoutId$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _removeListeners$1, {
	      writable: true,
	      value: null
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2] = textEditor;
	    const toolbarOptions = main_core.Type.isArray(_options) ? _options : [];
	    babelHelpers.classPrivateFieldLooseBase(this, _fillFromOptions)[_fillFromOptions](toolbarOptions);
	    if (babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].length > 0) {
	      babelHelpers.classPrivateFieldLooseBase(this, _removeListeners$1)[_removeListeners$1] = babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$c)[_registerListeners$c]();
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver] = new ResizeObserver(babelHelpers.classPrivateFieldLooseBase(this, _handleResize$2)[_handleResize$2].bind(this));
	    }
	  }
	  renderTo(container) {
	    if (this.isRendered()) {
	      return;
	    }
	    if (main_core.Type.isElementNode(container)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].forEach(item => {
	        main_core.Dom.append(item.render(), this.getItemsContainer());
	      });
	      main_core.Dom.append(this.getContainer(), container);
	      if (babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver] !== null) {
	        babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver].observe(this.getContainer());
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _rendered)[_rendered] = true;
	    }
	  }
	  isEmpty() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].length === 0;
	  }
	  getContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$8)[_refs$8].remember('container', () => {
	      return main_core.Tag.render(_t$e || (_t$e = _$e`
				<div class="ui-text-editor-toolbar-container">
					${0}
					${0}
				</div>
			`), this.getItemsContainer(), this.getMoreBtnContainer());
	    });
	  }
	  getItemsContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$8)[_refs$8].remember('items-container', () => {
	      return main_core.Tag.render(_t2$9 || (_t2$9 = _$e`
				<div class="ui-text-editor-toolbar-items"></div>
			`));
	    });
	  }
	  getMoreBtnContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$8)[_refs$8].remember('more-btn-container', () => {
	      return main_core.Tag.render(_t3$3 || (_t3$3 = _$e`
				<div class="ui-text-editor-toolbar-more-btn">
				${0}
				</div>
			`), this.getMoreBtn().render());
	    });
	  }
	  getMoreBtn() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _moreBtn)[_moreBtn] === null) {
	      const resetAnimation = () => {
	        main_core.Event.unbind(this.getItemsContainer(), 'transitionend', resetAnimation);
	        main_core.Dom.style(this.getItemsContainer(), {
	          height: null
	        });
	        main_core.Dom.removeClass(this.getItemsContainer(), '--animating');
	      };
	      babelHelpers.classPrivateFieldLooseBase(this, _moreBtn)[_moreBtn] = new Button();
	      babelHelpers.classPrivateFieldLooseBase(this, _moreBtn)[_moreBtn].setContent('<span class="ui-text-editor-toolbar-more-btn-icon"></span>');
	      babelHelpers.classPrivateFieldLooseBase(this, _moreBtn)[_moreBtn].subscribe('onClick', () => {
	        main_core.Event.unbind(this.getItemsContainer(), 'transitionend', resetAnimation);
	        if (main_core.Dom.hasClass(this.getContainer(), '--expanded')) {
	          main_core.Dom.style(this.getItemsContainer(), {
	            height: `${this.getItemsContainer().scrollHeight}px`
	          });
	          requestAnimationFrame(() => {
	            main_core.Dom.removeClass(this.getContainer(), '--expanded');
	            main_core.Dom.addClass(this.getItemsContainer(), '--animating');
	            main_core.Dom.style(this.getItemsContainer(), {
	              height: null
	            });
	          });
	        } else {
	          main_core.Dom.addClass(this.getItemsContainer(), '--animating');
	          main_core.Dom.style(this.getItemsContainer(), {
	            height: `${this.getItemsContainer().scrollHeight}px`
	          });
	          main_core.Dom.addClass(this.getContainer(), '--expanded');
	        }
	        main_core.Event.bind(this.getItemsContainer(), 'transitionend', resetAnimation);
	      });
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _moreBtn)[_moreBtn];
	  }
	  getItems() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _items)[_items];
	  }
	  isRendered() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _rendered)[_rendered];
	  }
	  destroy() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _removeListeners$1)[_removeListeners$1] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _removeListeners$1)[_removeListeners$1]();
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver].disconnect();
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver)[_resizeObserver] = null;
	    }
	    if (this.isRendered()) {
	      main_core.Dom.remove(this.getContainer());
	    }
	    if (babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]) {
	      clearTimeout(babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]);
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _items)[_items] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _refs$8)[_refs$8] = null;
	  }
	  update() {
	    babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].getEditorState().read(() => {
	      let selection = ui_lexical_core.$getSelection();
	      if (!ui_lexical_core.$isRangeSelection(selection)) {
	        selection = null;
	      }
	      let unformattedNode = null;
	      if (selection !== null) {
	        unformattedNode = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => {
	          return (node.__flags & UNFORMATTED) !== 0;
	        });
	      }
	      const blockTypes = selection === null ? new Set() : babelHelpers.classPrivateFieldLooseBase(this, _getSelectionBlockTypes)[_getSelectionBlockTypes](selection);
	      const isReadOnly = !babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].isEditable();
	      babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].forEach(item => {
	        if (!(item instanceof Button)) {
	          return;
	        }

	        // First let's figure out a disabled status
	        if (item.hasOwnDisableCallback()) {
	          item.setDisabled(item.invokeDisableCallback());
	        } else if (isReadOnly) {
	          item.disable();
	        } else if (unformattedNode !== null && item.shouldDisableInsideUnformatted()) {
	          item.disable();
	        } else {
	          item.enable();
	        }

	        // Now set an active status
	        if (item.isDisabled()) {
	          item.setActive(false);
	        } else if (item.hasFormat()) {
	          const format = item.getFormat();
	          item.setActive(selection === null ? false : selection.hasFormat(format));
	        } else if (item.getBlockType() !== null) {
	          item.setActive(blockTypes.has(item.getBlockType()));
	        }
	      });
	    });
	  }
	  reset() {
	    babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].forEach(item => {
	      if (item instanceof Button) {
	        item.setActive(false);
	      }
	    });
	  }
	}
	function _registerListeners2$c() {
	  return ui_lexical_utils.mergeRegister(babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].registerCommand(ui_lexical_core.SELECTION_CHANGE_COMMAND, () => {
	    this.update();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].registerCommand(ui_lexical_core.FOCUS_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]) {
	      clearTimeout(babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]);
	      babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1] = null;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].registerCommand(ui_lexical_core.BLUR_COMMAND, () => {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]) {
	      clearTimeout(babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1]);
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _timeoutId$1)[_timeoutId$1] = setTimeout(() => {
	      const activeElement = document.activeElement;
	      const rootElement = babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].getScrollerContainer();
	      if (activeElement === null || !rootElement.contains(activeElement)) {
	        this.reset();
	      }
	    }, 400);
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].registerUpdateListener(() => {
	    this.update();
	  }), babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].registerEditableListener(() => {
	    this.update();
	  }));
	}
	function _fillFromOptions2(options) {
	  options.forEach(item => {
	    if (item === '|') {
	      babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].push(new Separator());
	    } else {
	      const component = babelHelpers.classPrivateFieldLooseBase(this, _textEditor$2)[_textEditor$2].getComponentRegistry().create(item);
	      if (component === null) {
	        // eslint-disable-next-line no-console
	        console.warn(`TextEditor Toolbar: "${item}" component doesn't exist.`);
	      } else {
	        babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].push(component);
	      }
	    }
	  });
	}
	function _handleResize2$2(entries) {
	  if (this.getContainer().offsetWidth === 0 || main_core.Dom.hasClass(this.getItemsContainer(), '--animating')) {
	    return;
	  }
	  const lastItem = babelHelpers.classPrivateFieldLooseBase(this, _items)[_items].at(-1);
	  if (!lastItem || lastItem.getContainer().offsetTop >= lastItem.getContainer().offsetHeight) {
	    main_core.Dom.addClass(this.getContainer(), '--overflowed');
	  } else {
	    main_core.Dom.removeClass(this.getContainer(), ['--overflowed', '--expanded']);
	  }
	}
	function _getSelectionBlockTypes2(selection) {
	  const anchorNode = selection.anchor.getNode();
	  const blockTypes = new Set();
	  let currentNode = anchorNode;
	  while (currentNode !== ui_lexical_core.$getRoot() && currentNode !== null) {
	    const blockType = babelHelpers.classPrivateFieldLooseBase(this, _getBlockType)[_getBlockType](currentNode);
	    blockTypes.add(blockType);
	    currentNode = currentNode.getParent();
	  }
	  return blockTypes;
	}
	function _getBlockType2(node) {
	  if (ui_lexical_list.$isListNode(node)) {
	    const listNode = node;
	    const parentList = ui_lexical_utils.$getNearestNodeOfType(listNode, ui_lexical_list.ListNode);
	    return parentList ? parentList.getListType() : listNode.getListType();
	  }
	  if (ui_lexical_link.$isLinkNode(node) || ui_lexical_link.$isAutoLinkNode(node)) {
	    return 'link';
	  }
	  if ($isCodeTokenNode(node)) {
	    return 'code';
	  }
	  return node.getType();
	}

	let _$f = t => t,
	  _t$f;
	var _popup$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("popup");
	var _toolbar = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("toolbar");
	var _showDebounced = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("showDebounced");
	var _onEditorScroll$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("onEditorScroll");
	var _registerListeners$d = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerListeners");
	var _show$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("show");
	var _adjustDialogPosition$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("adjustDialogPosition");
	var _initDialogPosition = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initDialogPosition");
	var _handleEditorScroll$5 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleEditorScroll");
	var _shouldShowDialog = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("shouldShowDialog");
	class FloatingToolbarPlugin extends BasePlugin {
	  constructor(editor) {
	    super(editor);
	    Object.defineProperty(this, _shouldShowDialog, {
	      value: _shouldShowDialog2
	    });
	    Object.defineProperty(this, _handleEditorScroll$5, {
	      value: _handleEditorScroll2$5
	    });
	    Object.defineProperty(this, _initDialogPosition, {
	      value: _initDialogPosition2
	    });
	    Object.defineProperty(this, _adjustDialogPosition$2, {
	      value: _adjustDialogPosition2$2
	    });
	    Object.defineProperty(this, _show$1, {
	      value: _show2$1
	    });
	    Object.defineProperty(this, _registerListeners$d, {
	      value: _registerListeners2$d
	    });
	    Object.defineProperty(this, _popup$5, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _toolbar, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _showDebounced, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _onEditorScroll$5, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleEditorScroll$5)[_handleEditorScroll$5].bind(this)
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _showDebounced)[_showDebounced] = main_core.Runtime.debounce(() => {
	      this.getEditor().update(() => {
	        if (babelHelpers.classPrivateFieldLooseBase(this, _shouldShowDialog)[_shouldShowDialog]()) {
	          babelHelpers.classPrivateFieldLooseBase(this, _show$1)[_show$1]();
	        }
	      });
	    }, 700);
	  }
	  static getName() {
	    return 'FloatingToolbar';
	  }
	  afterInit() {
	    const toolbarOptions = this.getEditor().getOption('floatingToolbar', []);
	    babelHelpers.classPrivateFieldLooseBase(this, _toolbar)[_toolbar] = new Toolbar(this.getEditor(), toolbarOptions);
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _toolbar)[_toolbar].isEmpty()) {
	      this.cleanUpRegister(babelHelpers.classPrivateFieldLooseBase(this, _registerListeners$d)[_registerListeners$d]());
	    }
	  }
	  update() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _shouldShowDialog)[_shouldShowDialog]()) {
	      if (this.getPopup().isShown()) {
	        babelHelpers.classPrivateFieldLooseBase(this, _show$1)[_show$1]();
	      } else {
	        babelHelpers.classPrivateFieldLooseBase(this, _showDebounced)[_showDebounced]();
	      }
	    } else {
	      this.getPopup().close();
	    }
	  }
	  getPopup() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5] === null) {
	      const container = main_core.Tag.render(_t$f || (_t$f = _$f`<div class="ui-text-editor-floating-toolbar"></div>`));
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5] = new main_popup.Popup({
	        closeByEsc: true,
	        // for an embedded popup: document.body -> this.getEditor().getScrollerContainer()
	        targetContainer: document.body,
	        autoHide: true,
	        content: container,
	        autoHideHandler: event => {
	          let collapsed = true;
	          const nativeSelection = window.getSelection();
	          if (nativeSelection.isCollapsed) {
	            return true;
	          }
	          this.getEditor().update(() => {
	            const selection = ui_lexical_core.$getSelection();
	            collapsed = selection === null || selection.isCollapsed();
	          });
	          return collapsed;
	        },
	        events: {
	          onShow: () => {
	            if (babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition$2)[_adjustDialogPosition$2]()) {
	              main_core.Event.bind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$5)[_onEditorScroll$5]);
	            }
	          },
	          onClose: () => {
	            main_core.Event.unbind(this.getEditor().getScrollerContainer(), 'scroll', babelHelpers.classPrivateFieldLooseBase(this, _onEditorScroll$5)[_onEditorScroll$5]);
	            clearDialogPosition(this.getPopup());
	          }
	        }
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _toolbar)[_toolbar].renderTo(container);
	    }
	    return babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5];
	  }
	  hide() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5] === null) {
	      return;
	    }
	    this.getPopup().close();
	  }
	  destroy() {
	    super.destroy();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5] !== null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5].destroy();
	      babelHelpers.classPrivateFieldLooseBase(this, _popup$5)[_popup$5] = null;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _toolbar)[_toolbar].destroy();
	    babelHelpers.classPrivateFieldLooseBase(this, _toolbar)[_toolbar] = null;
	  }
	}
	function _registerListeners2$d() {
	  return ui_lexical_utils.mergeRegister(this.getEditor().registerCommand(ui_lexical_core.SELECTION_CHANGE_COMMAND, () => {
	    this.update();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), this.getEditor().registerUpdateListener(({
	    editorState
	  }) => {
	    editorState.read(() => {
	      this.update();
	    });
	  }), this.getEditor().registerCommand(HIDE_DIALOG_COMMAND, () => {
	    this.hide();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}
	function _show2$1() {
	  this.getPopup().show();
	  clearDialogPosition(this.getPopup());
	  babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition$2)[_adjustDialogPosition$2]();
	}
	function _adjustDialogPosition2$2() {
	  return $adjustDialogPosition(this.getPopup(), this.getEditor(), babelHelpers.classPrivateFieldLooseBase(this, _initDialogPosition)[_initDialogPosition]);
	}
	function _initDialogPosition2(selectionPosition) {
	  const {
	    isBackward,
	    isMultiline
	  } = selectionPosition;
	  return isBackward || !isMultiline ? 'top' : 'bottom';
	}
	function _handleEditorScroll2$5() {
	  this.getEditor().update(() => {
	    babelHelpers.classPrivateFieldLooseBase(this, _adjustDialogPosition$2)[_adjustDialogPosition$2]();
	  });
	}
	function _shouldShowDialog2() {
	  if (this.getEditor().isComposing() || !this.getEditor().isEditable()) {
	    return false;
	  }
	  const selection = ui_lexical_core.$getSelection();
	  if (!ui_lexical_core.$isRangeSelection(selection) || selection.isCollapsed()) {
	    return false;
	  }
	  const nativeSelection = window.getSelection();
	  if (nativeSelection === null || nativeSelection.isCollapsed) {
	    return false;
	  }
	  const scrollerContainer = this.getEditor().getScrollerContainer();
	  if (!scrollerContainer.contains(nativeSelection.anchorNode)) {
	    return false;
	  }
	  const $isUnformatted = ui_lexical_utils.$findMatchingParent(selection.anchor.getNode(), node => {
	    return (node.__flags & UNFORMATTED) !== 0;
	  });
	  if ($isUnformatted || selection.getTextContent() === '') {
	    return false;
	  }
	  const rawTextContent = selection.getTextContent().replaceAll('\n', '');
	  if (!selection.isCollapsed() && rawTextContent === '') {
	    return false;
	  }
	  const node = getSelectedNode(selection);
	  const parent = node.getParent();
	  if (ui_lexical_link.$isLinkNode(parent) || ui_lexical_link.$isLinkNode(node)) {
	    return false;
	  }
	  const isSomeDialogVisible = this.getEditor().dispatchCommand(DIALOG_VISIBILITY_COMMAND);
	  if (isSomeDialogVisible) {
	    return false;
	  }
	  return ui_lexical_core.$isTextNode(node);
	}



	var FloatingToolbar = /*#__PURE__*/Object.freeze({
		FloatingToolbarPlugin: FloatingToolbarPlugin
	});

	const TOGGLE_TOOLBAR_COMMAND = ui_lexical_core.createCommand('TOGGLE_TOOLBAR_COMMAND');
	const SHOW_TOOLBAR_COMMAND = ui_lexical_core.createCommand('SHOW_TOOLBAR_COMMAND');
	const HIDE_TOOLBAR_COMMAND = ui_lexical_core.createCommand('HIDE_TOOLBAR_COMMAND');
	var _toolbar$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("toolbar");
	var _registerCommands$b = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	class ToolbarPlugin extends BasePlugin {
	  constructor(...args) {
	    super(...args);
	    Object.defineProperty(this, _registerCommands$b, {
	      value: _registerCommands2$b
	    });
	    Object.defineProperty(this, _toolbar$1, {
	      writable: true,
	      value: null
	    });
	  }
	  static getName() {
	    return 'Toolbar';
	  }
	  getToolbar() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1];
	  }
	  isRendered() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1] !== null && babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1].isRendered();
	  }
	  show() {
	    if (this.isRendered()) {
	      main_core.Dom.removeClass(this.getEditor().getToolbarContainer(), '--hidden');
	    }
	  }
	  hide() {
	    if (this.isRendered()) {
	      main_core.Dom.addClass(this.getEditor().getToolbarContainer(), '--hidden');
	    }
	  }
	  isShown() {
	    return this.isRendered() && !main_core.Dom.hasClass(this.getEditor().getToolbarContainer(), '--hidden');
	  }
	  toggle() {
	    if (this.isShown()) {
	      this.hide();
	    } else {
	      this.show();
	    }
	  }
	  afterInit() {
	    babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1] = new Toolbar(this.getEditor(), this.getEditor().getOption('toolbar'));
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1].isEmpty()) {
	      babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$b)[_registerCommands$b]();
	      babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1].renderTo(this.getEditor().getToolbarContainer());
	      const hideToolbar = this.getEditor().getOption('hideToolbar', false);
	      if (hideToolbar) {
	        this.hide();
	      }
	    }
	  }
	  destroy() {
	    super.destroy();
	    babelHelpers.classPrivateFieldLooseBase(this, _toolbar$1)[_toolbar$1].destroy();
	  }
	}
	function _registerCommands2$b() {
	  this.cleanUpRegister(this.getEditor().registerCommand(TOGGLE_TOOLBAR_COMMAND, () => {
	    this.toggle();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(SHOW_TOOLBAR_COMMAND, () => {
	    this.show();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.getEditor().registerCommand(HIDE_TOOLBAR_COMMAND, () => {
	    this.hide();
	    return true;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW));
	}



	var Toolbar$1 = /*#__PURE__*/Object.freeze({
		TOGGLE_TOOLBAR_COMMAND: TOGGLE_TOOLBAR_COMMAND,
		SHOW_TOOLBAR_COMMAND: SHOW_TOOLBAR_COMMAND,
		HIDE_TOOLBAR_COMMAND: HIDE_TOOLBAR_COMMAND,
		ToolbarPlugin: ToolbarPlugin
	});

	let _$g = t => t,
	  _t$g;
	var _placeholder = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("placeholder");
	var _placeholderNode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("placeholderNode");
	var _paragraphPlaceholder = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("paragraphPlaceholder");
	var _registerPlaceholderListeners = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerPlaceholderListeners");
	var _togglePlaceholder = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("togglePlaceholder");
	var _hasFocus = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("hasFocus");
	var _hidePlaceholder = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("hidePlaceholder");
	var _registerParagraphListeners = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerParagraphListeners");
	class PlaceholderPlugin extends BasePlugin {
	  constructor(...args) {
	    super(...args);
	    Object.defineProperty(this, _registerParagraphListeners, {
	      value: _registerParagraphListeners2
	    });
	    Object.defineProperty(this, _hidePlaceholder, {
	      value: _hidePlaceholder2
	    });
	    Object.defineProperty(this, _hasFocus, {
	      value: _hasFocus2
	    });
	    Object.defineProperty(this, _togglePlaceholder, {
	      value: _togglePlaceholder2
	    });
	    Object.defineProperty(this, _registerPlaceholderListeners, {
	      value: _registerPlaceholderListeners2
	    });
	    Object.defineProperty(this, _placeholder, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _placeholderNode, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _paragraphPlaceholder, {
	      writable: true,
	      value: null
	    });
	  }
	  afterInit() {
	    const placeholder = this.getEditor().getOption('placeholder');
	    if (main_core.Type.isStringFilled(placeholder)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _placeholder)[_placeholder] = placeholder;
	      babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode] = main_core.Tag.render(_t$g || (_t$g = _$g`
				<div class="ui-text-editor-placeholder">${0}</div>
			`), main_core.Text.encode(babelHelpers.classPrivateFieldLooseBase(this, _placeholder)[_placeholder]));
	      main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode], this.getEditor().getScrollerContainer());
	      babelHelpers.classPrivateFieldLooseBase(this, _registerPlaceholderListeners)[_registerPlaceholderListeners]();
	    }
	    let paragraphPlaceholder = this.getEditor().getOption('paragraphPlaceholder');
	    if (main_core.Type.isStringFilled(paragraphPlaceholder)) {
	      if (paragraphPlaceholder === 'auto') {
	        const copilotPlugin = this.getEditor().getPlugin('Copilot');
	        const copilotEnabled = copilotPlugin !== null && copilotPlugin.shouldTriggerBySpace();
	        const mentionPlugin = this.getEditor().getPlugin('Mention');
	        const mentionEnabled = mentionPlugin !== null && mentionPlugin.shouldTriggerByAtSign();
	        if (copilotEnabled && mentionEnabled) {
	          paragraphPlaceholder = main_core.Loc.getMessage('TEXT_EDITOR_PLACEHOLDER_MENTION_COPILOT');
	        } else if (copilotEnabled) {
	          paragraphPlaceholder = main_core.Loc.getMessage('TEXT_EDITOR_PLACEHOLDER_COPILOT');
	        } else if (mentionEnabled) {
	          paragraphPlaceholder = main_core.Loc.getMessage('TEXT_EDITOR_PLACEHOLDER_MENTION');
	        }
	      }
	      if (paragraphPlaceholder !== 'auto') {
	        babelHelpers.classPrivateFieldLooseBase(this, _paragraphPlaceholder)[_paragraphPlaceholder] = paragraphPlaceholder;
	        babelHelpers.classPrivateFieldLooseBase(this, _registerParagraphListeners)[_registerParagraphListeners]();
	      }
	    }
	  }
	  static getName() {
	    return 'Placeholder';
	  }
	}
	function _registerPlaceholderListeners2() {
	  this.cleanUpRegister(this.getEditor().registerUpdateListener(() => {
	    this.getEditor().getEditorState().read(() => {
	      babelHelpers.classPrivateFieldLooseBase(this, _togglePlaceholder)[_togglePlaceholder]();
	    });
	  }));
	}
	function _togglePlaceholder2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _placeholder)[_placeholder] === null) {
	    return;
	  }
	  let canShowPlaceholder = ui_lexical_text.$canShowPlaceholder(this.getLexicalEditor().isComposing());
	  if (canShowPlaceholder && babelHelpers.classPrivateFieldLooseBase(this, _paragraphPlaceholder)[_paragraphPlaceholder] !== null && babelHelpers.classPrivateFieldLooseBase(this, _hasFocus)[_hasFocus]()) {
	    canShowPlaceholder = false;
	  }
	  if (canShowPlaceholder) {
	    main_core.Dom.addClass(babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode], '--shown');
	  } else {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode], '--shown');
	  }
	}
	function _hasFocus2() {
	  const activeElement = document.activeElement;
	  const rootElement = this.getEditor().getRootElement();
	  return rootElement !== null && activeElement !== null && rootElement.contains(activeElement);
	}
	function _hidePlaceholder2() {
	  if (babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode] !== null) {
	    main_core.Dom.removeClass(babelHelpers.classPrivateFieldLooseBase(this, _placeholderNode)[_placeholderNode], '--shown');
	  }
	}
	function _registerParagraphListeners2() {
	  let lastEmptyParagraph = null;
	  const resetParagraphPlaceholder = () => {
	    if (lastEmptyParagraph) {
	      const htmlElement = this.getEditor().getElementByKey(lastEmptyParagraph.getKey());
	      if (htmlElement) {
	        delete htmlElement.dataset.placeholder;
	      }
	    }
	  };
	  this.cleanUpRegister(this.getEditor().registerCommand(ui_lexical_core.SELECTION_CHANGE_COMMAND, () => {
	    if (!this.getEditor().isEditable()) {
	      return false;
	    }
	    const selection = ui_lexical_core.$getSelection();
	    let currentParagraph = null;
	    if (ui_lexical_core.$isRangeSelection(selection) && selection.isCollapsed()) {
	      const node = selection.anchor.getNode();
	      if (ui_lexical_core.$isParagraphNode(node) && ui_lexical_core.$isRootNode(node.getParent()) && node.isEmpty()) {
	        const htmlElement = this.getEditor().getElementByKey(node.getKey());
	        if (htmlElement && babelHelpers.classPrivateFieldLooseBase(this, _hasFocus)[_hasFocus]()) {
	          htmlElement.dataset.placeholder = babelHelpers.classPrivateFieldLooseBase(this, _paragraphPlaceholder)[_paragraphPlaceholder];
	          currentParagraph = node;
	          babelHelpers.classPrivateFieldLooseBase(this, _hidePlaceholder)[_hidePlaceholder]();
	        }
	      }
	    }
	    if (lastEmptyParagraph && lastEmptyParagraph !== currentParagraph) {
	      resetParagraphPlaceholder();
	    }
	    lastEmptyParagraph = currentParagraph;
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), this.getEditor().registerCommand(ui_lexical_core.PASTE_COMMAND, () => {
	    resetParagraphPlaceholder();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL),
	  // this.getEditor().registerCommand(
	  // 	FOCUS_COMMAND,
	  // 	(): boolean => {
	  // 		resetParagraphPlaceholder();
	  //
	  // 		return false;
	  // 	},
	  // 	COMMAND_PRIORITY_CRITICAL,
	  // ),
	  this.getEditor().registerCommand(ui_lexical_core.BLUR_COMMAND, () => {
	    resetParagraphPlaceholder();
	    babelHelpers.classPrivateFieldLooseBase(this, _togglePlaceholder)[_togglePlaceholder]();
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL));
	}

	let _$h = t => t,
	  _t$h,
	  _t2$a,
	  _t3$4,
	  _t4$1,
	  _t5,
	  _t6,
	  _t7,
	  _t8,
	  _t9,
	  _t10;
	const CollapsingState = {
	  COLLAPSED: 'collapsed',
	  COLLAPSING: 'collapsing',
	  EXPANDED: 'expanded',
	  EXPANDING: 'expanding'
	};

	/**
	 * @memberof BX.UI.TextEditor
	 */
	var _lexicalEditor = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("lexicalEditor");
	var _componentRegistry = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("componentRegistry");
	var _refs$9 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("refs");
	var _options$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("options");
	var _plugins$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("plugins");
	var _newLineMode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("newLineMode");
	var _bbcodeScheme = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("bbcodeScheme");
	var _schemeValidation = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("schemeValidation");
	var _bbcodeImportMap = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("bbcodeImportMap");
	var _bbcodeExportMap = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("bbcodeExportMap");
	var _themeClasses = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("themeClasses");
	var _decoratorNodes = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("decoratorNodes");
	var _decoratorComponents = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("decoratorComponents");
	var _removeListeners$2 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("removeListeners");
	var _highlightContainer = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("highlightContainer");
	var _autoFocus = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("autoFocus");
	var _minHeight$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("minHeight");
	var _maxHeight$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("maxHeight");
	var _collapsingMode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("collapsingMode");
	var _collapsingState = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("collapsingState");
	var _collapsingTransitionEnd = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("collapsingTransitionEnd");
	var _paragraphHeight = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("paragraphHeight");
	var _resizeObserver$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("resizeObserver");
	var _destroying = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("destroying");
	var _rendered$1 = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("rendered");
	var _prevEmptyStatus = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("prevEmptyStatus");
	var _initEditorState = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initEditorState");
	var _initDecorateNodes = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initDecorateNodes");
	var _registerCommands$c = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("registerCommands");
	var _createNamespace = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("createNamespace");
	var _initBBCodeImportMap = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initBBCodeImportMap");
	var _initBBCodeExportMap = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initBBCodeExportMap");
	var _initBBCodeScheme = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initBBCodeScheme");
	var _initCollapsingMode = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("initCollapsingMode");
	var _collapse = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("collapse");
	var _handleCollapsingTransition = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("handleCollapsingTransition");
	class TextEditor extends main_core_events.EventEmitter {
	  constructor(editorOptions) {
	    super();
	    Object.defineProperty(this, _handleCollapsingTransition, {
	      value: _handleCollapsingTransition2
	    });
	    Object.defineProperty(this, _collapse, {
	      value: _collapse2
	    });
	    Object.defineProperty(this, _initCollapsingMode, {
	      value: _initCollapsingMode2
	    });
	    Object.defineProperty(this, _initBBCodeScheme, {
	      value: _initBBCodeScheme2
	    });
	    Object.defineProperty(this, _initBBCodeExportMap, {
	      value: _initBBCodeExportMap2
	    });
	    Object.defineProperty(this, _initBBCodeImportMap, {
	      value: _initBBCodeImportMap2
	    });
	    Object.defineProperty(this, _createNamespace, {
	      value: _createNamespace2
	    });
	    Object.defineProperty(this, _registerCommands$c, {
	      value: _registerCommands2$c
	    });
	    Object.defineProperty(this, _initDecorateNodes, {
	      value: _initDecorateNodes2
	    });
	    Object.defineProperty(this, _initEditorState, {
	      value: _initEditorState2
	    });
	    Object.defineProperty(this, _lexicalEditor, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _componentRegistry, {
	      writable: true,
	      value: new ComponentRegistry()
	    });
	    Object.defineProperty(this, _refs$9, {
	      writable: true,
	      value: new main_core.Cache.MemoryCache()
	    });
	    Object.defineProperty(this, _options$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _plugins$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _newLineMode, {
	      writable: true,
	      value: NewLineMode.MIXED
	    });
	    Object.defineProperty(this, _bbcodeScheme, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _schemeValidation, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _bbcodeImportMap, {
	      writable: true,
	      value: void 0
	    });
	    Object.defineProperty(this, _bbcodeExportMap, {
	      writable: true,
	      value: void 0
	    });
	    Object.defineProperty(this, _themeClasses, {
	      writable: true,
	      value: {}
	    });
	    Object.defineProperty(this, _decoratorNodes, {
	      writable: true,
	      value: new Set()
	    });
	    Object.defineProperty(this, _decoratorComponents, {
	      writable: true,
	      value: new Map()
	    });
	    Object.defineProperty(this, _removeListeners$2, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _highlightContainer, {
	      writable: true,
	      value: main_core.Tag.render(_t$h || (_t$h = _$h`<div class="ui-text-editor-selection-highlighting"></div>`))
	    });
	    Object.defineProperty(this, _autoFocus, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _minHeight$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _maxHeight$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _collapsingMode, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _collapsingState, {
	      writable: true,
	      value: CollapsingState.EXPANDED
	    });
	    Object.defineProperty(this, _collapsingTransitionEnd, {
	      writable: true,
	      value: babelHelpers.classPrivateFieldLooseBase(this, _handleCollapsingTransition)[_handleCollapsingTransition].bind(this)
	    });
	    Object.defineProperty(this, _paragraphHeight, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _resizeObserver$1, {
	      writable: true,
	      value: null
	    });
	    Object.defineProperty(this, _destroying, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _rendered$1, {
	      writable: true,
	      value: false
	    });
	    Object.defineProperty(this, _prevEmptyStatus, {
	      writable: true,
	      value: true
	    });
	    this.setEventNamespace('BX.UI.TextEditor.Editor');
	    const defaultOptions = this.constructor.getDefaultOptions();
	    const _options2 = main_core.Type.isPlainObject(editorOptions) ? editorOptions : {};
	    babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1] = new main_core_collections.SettingsCollection({
	      ...defaultOptions,
	      ..._options2
	    });
	    const builtinPlugins = [...this.constructor.getBuiltinPlugins()];
	    const _plugins2 = babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('plugins', builtinPlugins);
	    const extraPlugins = babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('extraPlugins', []);
	    const pluginsToRemove = babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('removePlugins', []);
	    const newLineMode = babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('newLineMode');
	    if ([NewLineMode.LINE_BREAK, NewLineMode.PARAGRAPH].includes(newLineMode)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _newLineMode)[_newLineMode] = newLineMode;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _themeClasses)[_themeClasses] = defaultTheme;
	    babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1] = new PluginCollection(builtinPlugins, [..._plugins2, ...extraPlugins], pluginsToRemove);
	    const constructors = babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1].getConstructors();
	    const _nodes = constructors.map(pluginConstructor => {
	      return pluginConstructor.getNodes(this);
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor] = ui_lexical_core.createEditor({
	      // uses when you copy-paste from one to another editor
	      namespace: main_core.Type.isStringFilled(_options2.namespace) ? _options2.namespace : babelHelpers.classPrivateFieldLooseBase(this, _createNamespace)[_createNamespace](constructors),
	      nodes: _nodes.flat(),
	      onError: error => {
	        console.error(error);
	      },
	      theme: babelHelpers.classPrivateFieldLooseBase(this, _themeClasses)[_themeClasses],
	      editable: babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('editable') !== false
	    });
	    this.setMinHeight(_options2.minHeight);
	    this.setMaxHeight(_options2.maxHeight);
	    this.setAutoFocus(_options2.autoFocus);
	    this.setVisualOptions(_options2.visualOptions);
	    babelHelpers.classPrivateFieldLooseBase(this, _removeListeners$2)[_removeListeners$2] = ui_lexical_utils.mergeRegister(babelHelpers.classPrivateFieldLooseBase(this, _registerCommands$c)[_registerCommands$c](), babelHelpers.classPrivateFieldLooseBase(this, _initDecorateNodes)[_initDecorateNodes](_nodes.flat()));
	    babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1].init(this);
	    babelHelpers.classPrivateFieldLooseBase(this, _bbcodeImportMap)[_bbcodeImportMap] = babelHelpers.classPrivateFieldLooseBase(this, _initBBCodeImportMap)[_initBBCodeImportMap]();
	    babelHelpers.classPrivateFieldLooseBase(this, _bbcodeExportMap)[_bbcodeExportMap] = babelHelpers.classPrivateFieldLooseBase(this, _initBBCodeExportMap)[_initBBCodeExportMap]();
	    babelHelpers.classPrivateFieldLooseBase(this, _bbcodeScheme)[_bbcodeScheme] = babelHelpers.classPrivateFieldLooseBase(this, _initBBCodeScheme)[_initBBCodeScheme]();
	    babelHelpers.classPrivateFieldLooseBase(this, _schemeValidation)[_schemeValidation] = new SchemeValidation(this);
	    this.subscribeFromOptions(_options2.events);
	  }
	  static getBuiltinPlugins() {
	    return [RichTextPlugin, ParagraphPlugin, ClipboardPlugin, BoldPlugin, UnderlinePlugin, ItalicPlugin, StrikethroughPlugin, ClearFormatPlugin, TabIndentPlugin, CodePlugin, QuotePlugin, ListPlugin, MentionPlugin, LinkPlugin, AutoLinkPlugin, ImagePlugin, VideoPlugin, SmileyPlugin, SpoilerPlugin, TablePlugin, HashtagPlugin, CopilotPlugin, HistoryPlugin, BlockToolbarPlugin, FloatingToolbarPlugin, ToolbarPlugin, PlaceholderPlugin, FilePlugin];
	  }
	  static getDefaultOptions() {
	    return {};
	  }
	  getComponentRegistry() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _componentRegistry)[_componentRegistry];
	  }
	  getOptions() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1];
	  }
	  getOption(path, defaultValue = null) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get(path, defaultValue);
	  }
	  getThemeClasses() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _themeClasses)[_themeClasses];
	  }
	  getThemeClass(tagName) {
	    const className = babelHelpers.classPrivateFieldLooseBase(this, _themeClasses)[_themeClasses][tagName];
	    if (className !== undefined) {
	      return className;
	    }
	    return '';
	  }
	  getNewLineMode() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _newLineMode)[_newLineMode];
	  }
	  getBBCodeScheme() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _bbcodeScheme)[_bbcodeScheme];
	  }
	  getSchemeValidation() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _schemeValidation)[_schemeValidation];
	  }
	  setText(text, options) {
	    if (main_core.Type.isString(text)) {
	      const updateOptions = {
	        discrete: main_core.Type.isPlainObject(options) && options.discrete === true
	      };
	      babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].update(() => {
	        const lexicalNodes = $importFromBBCode(text, this);
	        const root = ui_lexical_core.$getRoot();
	        root.clear();
	        root.append(...lexicalNodes);
	        ui_lexical_core.$setSelection(null);
	      }, updateOptions);
	    }
	  }
	  clear(options) {
	    const updateOptions = {
	      discrete: main_core.Type.isPlainObject(options) && options.discrete === true
	    };
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].update(() => {
	      const root = ui_lexical_core.$getRoot();
	      const paragraph = ui_lexical_core.$createParagraphNode();
	      root.clear();
	      root.append(paragraph);

	      // const selection = $getSelection();
	      // if (selection !== null)
	      // {
	      // 	paragraph.select();
	      // }

	      ui_lexical_core.$setSelection(null);
	    }, updateOptions);
	  }
	  clearHistory() {
	    this.dispatchCommand(ui_lexical_core.CLEAR_HISTORY_COMMAND);
	  }
	  getText() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getEditorState().read(() => {
	      const bbCodeAst = $exportToBBCode(ui_lexical_core.$getRoot(), this);

	      // console.log("bbCodeAst", bbCodeAst);

	      return bbCodeAst.toString();
	    });
	  }
	  isEmpty(trim = true) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getEditorState().read(() => {
	      return $isRootEmpty(trim);
	    });
	  }
	  setAutoFocus(flag) {
	    if (main_core.Type.isBoolean(flag)) {
	      babelHelpers.classPrivateFieldLooseBase(this, _autoFocus)[_autoFocus] = flag;
	    }
	  }
	  hasAutoFocus() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _autoFocus)[_autoFocus];
	  }
	  setMinHeight(minHeight) {
	    if (main_core.Type.isNumber(minHeight) && minHeight > 0 || minHeight === null) {
	      const changed = babelHelpers.classPrivateFieldLooseBase(this, _minHeight$1)[_minHeight$1] !== minHeight;
	      babelHelpers.classPrivateFieldLooseBase(this, _minHeight$1)[_minHeight$1] = minHeight;
	      if (changed) {
	        main_core.Dom.style(this.getScrollerContainer(), '--ui-text-editor-min-height', minHeight > 0 ? `${minHeight}px` : null);
	      }
	    }
	  }
	  getMinHeight() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _minHeight$1)[_minHeight$1];
	  }
	  setMaxHeight(maxHeight) {
	    if (main_core.Type.isNumber(maxHeight) && maxHeight > 0 || maxHeight === null) {
	      const changed = babelHelpers.classPrivateFieldLooseBase(this, _maxHeight$1)[_maxHeight$1] !== maxHeight;
	      babelHelpers.classPrivateFieldLooseBase(this, _maxHeight$1)[_maxHeight$1] = maxHeight;
	      if (changed) {
	        main_core.Dom.style(this.getScrollerContainer(), '--ui-text-editor-max-height', maxHeight > 0 ? `${maxHeight}px` : null);
	      }
	    }
	  }
	  getMaxHeight() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _maxHeight$1)[_maxHeight$1];
	  }
	  setVisualOptions(options) {
	    if (!main_core.Type.isPlainObject(options)) {
	      return;
	    }
	    for (const [option, value] of Object.entries(options)) {
	      const name = main_core.Text.toKebabCase(option);
	      main_core.Dom.style(this.getRootContainer(), `--ui-text-editor-${name}`, value);
	    }
	  }
	  isCollapsingModeEnabled() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _collapsingMode)[_collapsingMode];
	  }
	  isCollapsed() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSED;
	  }
	  collapse(animate = true) {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapse)[_collapse]('hide', animate);
	  }
	  expand(animate = true) {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapse)[_collapse]('show', animate);
	  }
	  toggle(animate = true) {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapse)[_collapse]('toggle', animate);
	  }
	  getParagraphHeight() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _paragraphHeight)[_paragraphHeight] !== null) {
	      return babelHelpers.classPrivateFieldLooseBase(this, _paragraphHeight)[_paragraphHeight];
	    }
	    const className = this.getThemeClasses().paragraph || '';
	    const paragraph = main_core.Tag.render(_t2$a || (_t2$a = _$h`<p class="${0}"><br /></p>`), className);
	    main_core.Dom.style(paragraph, {
	      position: 'absolute',
	      transform: 'translateY(-1000px)'
	    });
	    main_core.Dom.append(paragraph, this.getScrollerContainer());
	    babelHelpers.classPrivateFieldLooseBase(this, _paragraphHeight)[_paragraphHeight] = paragraph.offsetHeight + main_core.Text.toNumber(main_core.Dom.style(paragraph, 'margin-top')) + main_core.Text.toNumber(main_core.Dom.style(paragraph, 'margin-bottom'));
	    main_core.Dom.remove(paragraph);
	    return babelHelpers.classPrivateFieldLooseBase(this, _paragraphHeight)[_paragraphHeight];
	  }
	  getLexicalEditor() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor];
	  }
	  setRootElement(contentEditableElement) {
	    if (main_core.Type.isElementNode(contentEditableElement) || contentEditableElement === null) {
	      babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].setRootElement(contentEditableElement);
	    }
	  }
	  getBBCodeExportMap() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _bbcodeExportMap)[_bbcodeExportMap];
	  }
	  getBBCodeImportMap() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _bbcodeImportMap)[_bbcodeImportMap];
	  }
	  getEditorState() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getEditorState();
	  }
	  getPlugins() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1];
	  }
	  getPlugin(key) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1].get(key);
	  }
	  getElementByKey(key) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getElementByKey(key);
	  }
	  setEditorState(editorState, options) {
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].setEditorState(editorState, options);
	  }
	  setEditable(editable) {
	    if (main_core.Type.isBoolean(editable)) {
	      this.dispatchCommand(HIDE_DIALOG_COMMAND);
	      if (!editable) {
	        this.blur();
	      }
	      babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].setEditable(editable);
	    }
	  }
	  isEditable() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].isEditable();
	  }
	  registerUpdateListener(listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerUpdateListener(listener);
	  }
	  registerEditableListener(listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerEditableListener(listener);
	  }
	  registerCommand(command, listener, priority) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerCommand(command, listener, priority);
	  }
	  dispatchCommand(type, payload) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].dispatchCommand(type, payload);
	  }
	  registerMutationListener(klass, listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerMutationListener(klass, listener);
	  }
	  registerNodeTransform(klass, listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerNodeTransform(klass, listener);
	  }
	  registerTextContentListener(listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerTextContentListener(listener);
	  }
	  registerDecoratorListener(listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerDecoratorListener(listener);
	  }
	  registerRootListener(listener) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerRootListener(listener);
	  }
	  registerEventListener(nodeType, eventType, eventListener) {
	    const isCaptured = ['mouseenter', 'mouseleave'].includes(eventType);
	    const handleEvent = event => {
	      this.update(() => {
	        const nearestNode = ui_lexical_core.$getNearestNodeFromDOMNode(event.target);
	        if (nearestNode !== null) {
	          const targetNode = isCaptured ? nearestNode instanceof nodeType ? nearestNode : null : ui_lexical_utils.$findMatchingParent(nearestNode, node => node instanceof nodeType);
	          if (targetNode !== null) {
	            eventListener(event, targetNode.getKey());
	          }
	        }
	      });
	    };
	    return this.registerRootListener((rootElement, prevRootElement) => {
	      if (rootElement) {
	        main_core.Event.bind(rootElement, eventType, handleEvent, isCaptured);
	      }
	      if (prevRootElement) {
	        main_core.Event.unbind(prevRootElement, eventType, handleEvent, isCaptured);
	      }
	    });
	  }
	  update(updateFn, options) {
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].update(updateFn, options);
	  }
	  focus(callbackFn, options) {
	    if (!document.hasFocus()) {
	      window.focus();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].focus(main_core.Type.isFunction(callbackFn) ? callbackFn : null, main_core.Type.isPlainObject(options) ? options : {
	      defaultSelection: 'rootStart'
	    });
	  }
	  hasFocus() {
	    return this.getRootElement().contains(document.activeElement);
	  }
	  blur() {
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].blur();
	  }
	  isComposing() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].isComposing();
	  }
	  getRootElement() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getRootElement();
	  }
	  hasNodes(nodes) {
	    return babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].hasNodes(nodes);
	  }
	  getRootContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('root', () => {
	      const classes = [this.isEditable() ? '--editable' : '--read-only'];
	      return main_core.Tag.render(_t3$4 || (_t3$4 = _$h`
				<div class="ui-text-editor ${0}">
					${0}
				</div>
			`), classes.join(' '), this.getInnerContainer());
	    });
	  }
	  getInnerContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('inner', () => {
	      return main_core.Tag.render(_t4$1 || (_t4$1 = _$h`
				<div class="ui-text-editor-inner">
					${0}
					${0}
					${0}
					${0}
				</div>
			`), this.getHeaderContainer(), this.getToolbarContainer(), this.getScrollerContainer(), this.getFooterContainer());
	    });
	  }
	  getToolbarContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('toolbar', () => {
	      return main_core.Tag.render(_t5 || (_t5 = _$h`
				<div class="ui-text-editor-toolbar" tabindex="-1"></div>
			`));
	    });
	  }
	  getScrollerContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('scroller', () => {
	      return main_core.Tag.render(_t6 || (_t6 = _$h`
				<div class="ui-text-editor-scroller">
					${0}
				</div>
			`), this.getEditableContainer());
	    });
	  }
	  getEditableContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('editable', () => {
	      return main_core.Tag.render(_t7 || (_t7 = _$h`
				<div 
					class="ui-text-editor-editable" 
					contenteditable="${0}" 
					spellcheck="true"
				></div>
			`), this.isEditable() ? 'true' : 'false');
	    });
	  }
	  getFooterContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('footer', () => {
	      return main_core.Tag.render(_t8 || (_t8 = _$h`
				<div class="ui-text-editor-slot ui-text-editor-footer" tabindex="-1"></div>
			`));
	    });
	  }
	  getHeaderContainer() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _refs$9)[_refs$9].remember('header', () => {
	      return main_core.Tag.render(_t9 || (_t9 = _$h`
				<div class="ui-text-editor-slot ui-text-editor-header" tabindex="-1"></div>
			`));
	    });
	  }
	  renderTo(container, replaceNode = false) {
	    if (!main_core.Type.isElementNode(container)) {
	      return;
	    }
	    if (!this.isRendered()) {
	      if (main_core.Type.isStringFilled(babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('content'))) {
	        this.setText(babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('content'));
	      } else {
	        babelHelpers.classPrivateFieldLooseBase(this, _initEditorState)[_initEditorState](babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('editorState'));
	      }
	    }
	    if (replaceNode) {
	      main_core.Dom.replace(container, this.getRootContainer());
	    } else {
	      main_core.Dom.append(this.getRootContainer(), container);
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].setRootElement(this.getEditableContainer());
	    if (this.hasAutoFocus()) {
	      this.focus(null, {
	        defaultSelection: 'rootStart'
	      });
	    }
	    if (!babelHelpers.classPrivateFieldLooseBase(this, _rendered$1)[_rendered$1]) {
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver$1)[_resizeObserver$1] = new ResizeObserver(() => {
	        this.emit('onResize');
	        this.dispatchCommand(HIDE_DIALOG_COMMAND, {
	          context: 'resize'
	        });
	      });
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver$1)[_resizeObserver$1].observe(this.getScrollerContainer());
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _rendered$1)[_rendered$1] = true;
	  }
	  isRendered() {
	    return babelHelpers.classPrivateFieldLooseBase(this, _rendered$1)[_rendered$1];
	  }
	  highlightSelection() {
	    this.getEditorState().read(() => {
	      const selection = ui_lexical_core.$getSelection();
	      if (!ui_lexical_core.$isRangeSelection(selection) || selection.isCollapsed()) {
	        return;
	      }
	      const anchor = selection.anchor;
	      const focus = selection.focus;
	      const range = ui_lexical_selection.createDOMRange(babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor], anchor.getNode(), anchor.offset, focus.getNode(), focus.offset);
	      if (range !== null) {
	        const scrollerContainer = this.getScrollerContainer();
	        const scrollerRect = scrollerContainer.getBoundingClientRect();
	        const selectionRects = ui_lexical_selection.createRectsFromDOMRange(babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor], range);
	        const selectionRectsLength = selectionRects.length;
	        babelHelpers.classPrivateFieldLooseBase(this, _highlightContainer)[_highlightContainer].innerHTML = '';
	        for (let i = 0; i < selectionRectsLength; i++) {
	          const selectionRect = selectionRects[i];
	          const elem = main_core.Tag.render(_t10 || (_t10 = _$h`<span class="ui-text-editor-selection-part"></span>`));
	          const top = selectionRect.top - scrollerRect.top + scrollerContainer.scrollTop;
	          const left = selectionRect.left - scrollerRect.left + scrollerContainer.scrollLeft;
	          main_core.Dom.style(elem, {
	            top: `${top}px`,
	            left: `${left}px`,
	            height: `${selectionRect.height}px`,
	            width: `${selectionRect.width}px`
	          });
	          main_core.Dom.append(elem, babelHelpers.classPrivateFieldLooseBase(this, _highlightContainer)[_highlightContainer]);
	        }
	        main_core.Dom.append(babelHelpers.classPrivateFieldLooseBase(this, _highlightContainer)[_highlightContainer], this.getScrollerContainer());
	      }
	    });
	  }
	  resetHighlightSelection() {
	    main_core.Dom.remove(babelHelpers.classPrivateFieldLooseBase(this, _highlightContainer)[_highlightContainer]);
	  }
	  destroy() {
	    if (babelHelpers.classPrivateFieldLooseBase(this, _destroying)[_destroying]) {
	      return;
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _destroying)[_destroying] = true;
	    this.emit('onDestroy');
	    for (const [, plugin] of babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1]) {
	      plugin.destroy();
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _removeListeners$2)[_removeListeners$2]();
	    if (this.isRendered()) {
	      babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver$1)[_resizeObserver$1].disconnect();
	      this.setRootElement(null);
	      main_core.Dom.remove(this.getRootContainer());
	    }
	    babelHelpers.classPrivateFieldLooseBase(this, _resizeObserver$1)[_resizeObserver$1] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor] = null;
	    this.$refs = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _schemeValidation)[_schemeValidation] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _bbcodeImportMap)[_bbcodeImportMap] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _bbcodeExportMap)[_bbcodeExportMap] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _decoratorNodes)[_decoratorNodes] = null;
	    babelHelpers.classPrivateFieldLooseBase(this, _decoratorComponents)[_decoratorComponents] = null;
	    Object.setPrototypeOf(this, null);
	  }
	}
	function _initEditorState2(initialEditorState, options) {
	  if (main_core.Type.isNil(initialEditorState)) {
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].update(() => {
	      const root = ui_lexical_core.$getRoot();
	      if (root.isEmpty()) {
	        const paragraph = ui_lexical_core.$createParagraphNode();
	        root.append(paragraph);
	      }
	    }, options);
	  } else if (main_core.Type.isPlainObject(initialEditorState) || main_core.Type.isStringFilled(initialEditorState)) {
	    const parsedEditorState = babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].parseEditorState(initialEditorState);
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].setEditorState(parsedEditorState);
	  } else if (main_core.Type.isFunction(initialEditorState)) {
	    babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].update(() => {
	      const root = ui_lexical_core.$getRoot();
	      if (root.isEmpty()) {
	        initialEditorState(babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor]);
	      }
	    }, options);
	  }
	}
	function _initDecorateNodes2(editorNodes) {
	  const removeListeners = [];
	  editorNodes.forEach(nodeClass => {
	    if (nodeClass.useDecoratorComponent) {
	      const removeListener = this.registerMutationListener(nodeClass, (nodes, payload) => {
	        for (const [key, val] of nodes) {
	          if (val === 'destroyed') {
	            const component = babelHelpers.classPrivateFieldLooseBase(this, _decoratorComponents)[_decoratorComponents].get(key);
	            if (component) {
	              component.destroy();
	            }
	            babelHelpers.classPrivateFieldLooseBase(this, _decoratorComponents)[_decoratorComponents].delete(key);
	          } else {
	            babelHelpers.classPrivateFieldLooseBase(this, _decoratorNodes)[_decoratorNodes].add(key);
	          }
	        }
	      });
	      removeListeners.push(removeListener);
	    }
	  });
	  const removeListener = babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].registerDecoratorListener(decorators => {
	    babelHelpers.classPrivateFieldLooseBase(this, _decoratorNodes)[_decoratorNodes].forEach(nodeKey => {
	      const decorator = decorators[nodeKey];
	      const {
	        componentClass: DecoratorClass,
	        options: decoratorOptions
	      } = decorator;
	      const component = babelHelpers.classPrivateFieldLooseBase(this, _decoratorComponents)[_decoratorComponents].get(nodeKey);
	      const htmlElement = babelHelpers.classPrivateFieldLooseBase(this, _lexicalEditor)[_lexicalEditor].getElementByKey(nodeKey);
	      if (htmlElement != null && htmlElement.innerHTML && component) {
	        component.update(decoratorOptions);
	      } else if (htmlElement) {
	        babelHelpers.classPrivateFieldLooseBase(this, _decoratorComponents)[_decoratorComponents].set(nodeKey, new DecoratorClass({
	          textEditor: this,
	          target: htmlElement,
	          nodeKey,
	          options: decoratorOptions
	        }));
	      }
	    });
	    babelHelpers.classPrivateFieldLooseBase(this, _decoratorNodes)[_decoratorNodes].clear();
	  });
	  removeListeners.push(removeListener);
	  return ui_lexical_utils.mergeRegister(...removeListeners);
	}
	function _registerCommands2$c() {
	  return ui_lexical_utils.mergeRegister(this.registerCommand(ui_lexical_core.FOCUS_COMMAND, () => {
	    if (this.isCollapsingModeEnabled() && babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSED && this.isEmpty(false)) {
	      this.expand();
	      return true;
	    }
	    this.emit('onFocus');
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), this.registerCommand(ui_lexical_core.BLUR_COMMAND, event => {
	    if (this.isCollapsingModeEnabled() && (babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSING || babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.EXPANDING)) {
	      return true;
	    }
	    this.emit('onBlur');
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_CRITICAL), this.registerUpdateListener(({
	    dirtyElements,
	    dirtyLeaves,
	    prevEditorState,
	    tags
	  }) => {
	    const isComposing = this.isComposing();
	    const hasContentChanges = dirtyLeaves.size > 0 || dirtyElements.size > 0;
	    if (isComposing || !hasContentChanges) {
	      return;
	    }
	    const isInitialChange = prevEditorState.isEmpty();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _options$1)[_options$1].get('collapsingMode') === true) {
	      if (isInitialChange) {
	        babelHelpers.classPrivateFieldLooseBase(this, _initCollapsingMode)[_initCollapsingMode]();
	      } else if (this.isCollapsed() && !this.isEmpty()) {
	        this.expand(false);
	      }
	    }
	    if (!isInitialChange && tags.has('history-merge')) {
	      return;
	    }
	    this.emit('onChange', {
	      isInitialChange,
	      tags
	    });
	    const isEmpty = this.isEmpty();
	    if (babelHelpers.classPrivateFieldLooseBase(this, _prevEmptyStatus)[_prevEmptyStatus] !== isEmpty) {
	      babelHelpers.classPrivateFieldLooseBase(this, _prevEmptyStatus)[_prevEmptyStatus] = isEmpty;
	      this.emit('onEmptyContentToggle', {
	        isEmpty,
	        isInitialChange
	      });
	    }
	  }), this.registerCommand(ui_lexical_core.KEY_ENTER_COMMAND, event => {
	    const {
	      code,
	      ctrlKey,
	      metaKey
	    } = event;
	    if (main_core.Browser.isMac() && metaKey || ctrlKey) {
	      this.emit('onMetaEnter');
	      return true;
	    }
	    if (code === 'Escape') {
	      this.emit('onEscape');
	      return true;
	    }
	    return false;
	  }, ui_lexical_core.COMMAND_PRIORITY_LOW), this.registerEditableListener(isEditable => {
	    this.getEditableContainer().contentEditable = isEditable;
	    if (isEditable) {
	      main_core.Dom.removeClass(this.getRootContainer(), '--read-only');
	      main_core.Dom.addClass(this.getRootContainer(), '--editable');
	    } else {
	      main_core.Dom.removeClass(this.getRootContainer(), '--editable');
	      main_core.Dom.addClass(this.getRootContainer(), '--read-only');
	    }
	    this.emit('onEditable', {
	      isEditable
	    });
	  }));
	}
	function _createNamespace2(plugins) {
	  const hashCode = createHashCode(plugins.map(node => node.getName()).sort().join('-'));
	  return String(hashCode);
	}
	function _initBBCodeImportMap2() {
	  const importMap = new Map();
	  for (const [, plugin] of babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1]) {
	    const map = plugin.importBBCode();
	    if (map !== null) {
	      Object.keys(map).forEach(key => {
	        let currentValue = importMap.get(key);
	        if (currentValue === undefined) {
	          currentValue = [];
	          importMap.set(key, currentValue);
	        }
	        currentValue.push(map[key]);
	      });
	    }
	  }
	  return importMap;
	}
	function _initBBCodeExportMap2() {
	  const exportMap = new Map();
	  for (const [, plugin] of babelHelpers.classPrivateFieldLooseBase(this, _plugins$1)[_plugins$1]) {
	    const map = plugin.exportBBCode();
	    if (map !== null) {
	      Object.keys(map).forEach(nodeType => {
	        if (main_core.Type.isFunction(map[nodeType])) {
	          exportMap.set(nodeType, map[nodeType]);
	        }
	      });
	    }
	  }
	  return exportMap;
	}
	function _initBBCodeScheme2() {
	  const filePlugin = this.getPlugin('File');
	  const fileTag = filePlugin != null && filePlugin.isEnabled() ? filePlugin.getMode() : 'none';
	  return new ui_bbcode_model.DefaultBBCodeScheme({
	    fileTag
	  });
	}
	function _initCollapsingMode2() {
	  babelHelpers.classPrivateFieldLooseBase(this, _collapsingMode)[_collapsingMode] = true;
	  if (this.isEmpty()) {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapse)[_collapse]('hide', false, true);
	  } else {
	    this.expand(false);
	  }
	}
	function _collapse2(mode = 'hide', animate = true, initialState = false) {
	  if (!this.isCollapsingModeEnabled()) {
	    return;
	  }
	  const collapsed = babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSED || babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSING;
	  const expanded = babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.EXPANDED || babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.EXPANDING;
	  if (mode === 'hide' && collapsed || mode === 'show' && expanded) {
	    return;
	  }
	  if (animate === false) {
	    if (collapsed) {
	      babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.EXPANDED;
	      main_core.Dom.removeClass(this.getRootContainer(), '--collapsed');
	      this.emit('onCollapsingToggle', {
	        isOpen: true
	      });
	      this.focus();
	    } else {
	      babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.COLLAPSED;
	      main_core.Dom.addClass(this.getRootContainer(), '--collapsed');
	      this.emit('onCollapsingToggle', {
	        isOpen: false
	      });
	      this.clear();
	      this.clearHistory();
	      if (!initialState) {
	        this.blur();
	      }
	    }
	    return;
	  }
	  main_core.Event.unbind(this.getRootContainer(), 'transitionend', babelHelpers.classPrivateFieldLooseBase(this, _collapsingTransitionEnd)[_collapsingTransitionEnd]);
	  if (collapsed) {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.EXPANDING;
	    this.blur(); // to avoid a root container scrolling because of a browser focus

	    const currentHeight = this.getRootContainer().offsetHeight;
	    main_core.Dom.removeClass(this.getRootContainer(), ['--collapsed', '--collapsing']);
	    main_core.Dom.style(this.getRootContainer(), {
	      height: `${currentHeight}px`,
	      overflow: 'hidden'
	    });
	    main_core.Dom.style(this.getInnerContainer(), {
	      opacity: 0
	    });
	    requestAnimationFrame(() => {
	      main_core.Dom.addClass(this.getRootContainer(), '--expanding');
	      main_core.Dom.style(this.getRootContainer(), {
	        height: `${this.getRootContainer().scrollHeight}px`
	      });
	      main_core.Dom.style(this.getInnerContainer(), {
	        opacity: 1
	      });
	      this.emit('onCollapsingToggle', {
	        isOpen: true
	      });
	    });
	  } else {
	    babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.COLLAPSING;
	    const currentHeight = this.getRootContainer().offsetHeight;
	    main_core.Dom.removeClass(this.getRootContainer(), ['--expanding']);
	    main_core.Dom.style(this.getRootContainer(), {
	      height: `${currentHeight}px`,
	      overflow: 'hidden'
	    });
	    main_core.Dom.style(this.getInnerContainer(), {
	      opacity: 1
	    });
	    this.blur();
	    const paragraphHeight = this.getParagraphHeight();
	    requestAnimationFrame(() => {
	      main_core.Dom.addClass(this.getRootContainer(), '--collapsing');
	      main_core.Dom.style(this.getRootContainer(), {
	        height: `${paragraphHeight}px`
	      });
	      main_core.Dom.style(this.getInnerContainer(), {
	        opacity: 0
	      });
	      this.emit('onCollapsingToggle', {
	        isOpen: false
	      });
	    });
	  }
	  main_core.Event.bind(this.getRootContainer(), 'transitionend', babelHelpers.classPrivateFieldLooseBase(this, _collapsingTransitionEnd)[_collapsingTransitionEnd]);
	}
	function _handleCollapsingTransition2() {
	  main_core.Event.unbind(this.getRootContainer(), 'transitionend', babelHelpers.classPrivateFieldLooseBase(this, _collapsingTransitionEnd)[_collapsingTransitionEnd]);
	  main_core.Dom.style(this.getRootContainer(), {
	    height: null,
	    overflow: null
	  });
	  main_core.Dom.style(this.getInnerContainer(), {
	    opacity: null
	  });
	  main_core.Dom.removeClass(this.getRootContainer(), ['--expanding', '--collapsing']);
	  if (babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] === CollapsingState.COLLAPSING) {
	    main_core.Dom.addClass(this.getRootContainer(), '--collapsed');
	    babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.COLLAPSED;
	    this.clear();
	    this.clearHistory();
	    this.blur();
	  } else {
	    this.focus();
	    babelHelpers.classPrivateFieldLooseBase(this, _collapsingState)[_collapsingState] = CollapsingState.EXPANDED;
	  }
	}

	const TextEditorComponent = {
	  name: 'TextEditorComponent',
	  props: {
	    editorOptions: {
	      type: Object
	    },
	    editorInstance: {
	      type: TextEditor,
	      default: null
	    },
	    events: {
	      type: Object,
	      default: {}
	    },
	    editable: {
	      type: Boolean,
	      default: null
	    }
	  },
	  setup() {
	    return {
	      editorClass: TextEditor
	    };
	  },
	  provide() {
	    return {
	      editor: this.editor
	    };
	  },
	  beforeCreate() {
	    if (this.editorInstance === null) {
	      this.hasOwnEditor = true;
	      const EditorClass = this.editorClass;
	      this.editor = new EditorClass(this.editorOptions);
	    } else {
	      this.hasOwnEditor = false;
	      this.editor = this.editorInstance;
	    }
	    if (main_core.Type.isPlainObject(this.events)) {
	      for (const [eventName, fn] of Object.entries(this.events)) {
	        this.editor.subscribe(eventName, fn);
	      }
	    }
	  },
	  computed: {
	    headerContainer() {
	      return this.editor.getHeaderContainer();
	    },
	    footerContainer() {
	      return this.editor.getFooterContainer();
	    }
	  },
	  watch: {
	    editable(value) {
	      this.editor.setEditable(value);
	    }
	  },
	  mounted() {
	    this.editor.renderTo(this.$refs.container, true);
	  },
	  unmounted() {
	    if (this.hasOwnEditor) {
	      this.editor.destroy();
	      this.editor = null;
	    }
	  },
	  template: `
		<div ref="container"></div>
		<Teleport :to="headerContainer">
			<slot name="header"></slot>
		</Teleport>
		<Teleport :to="footerContainer">
			<slot name="footer"></slot>
		</Teleport>
	`
	};

	/**
	 * @memberof BX.UI.TextEditor
	 */
	class BasicEditor extends TextEditor {
	  static getDefaultOptions() {
	    return {
	      plugins: ['RichText', 'Paragraph', 'Clipboard', 'Bold', 'Underline', 'Italic', 'Strikethrough', 'TabIndent', 'List', 'Mention', 'Link', 'AutoLink', 'Image', 'Copilot', 'History', 'BlockToolbar', 'FloatingToolbar', 'Toolbar', 'Placeholder', 'File'],
	      toolbar: ['bold', 'italic', 'underline', 'strikethrough', '|', 'numbered-list', 'bulleted-list', '|', 'link', 'copilot'],
	      newLineMode: NewLineMode.MIXED
	    };
	  }
	}

	const BasicEditorComponent = {
	  name: 'BasicEditorComponent',
	  extends: TextEditorComponent,
	  setup() {
	    return {
	      editorClass: BasicEditor
	    };
	  }
	};

	/**
	 * @namespace BX.UI.TextEditor.Plugins
	 */
	const Plugins = {
	  Paragraph,
	  AutoLink,
	  BlockToolbar,
	  Bold,
	  Code,
	  FloatingToolbar,
	  History,
	  Image,
	  Italic,
	  Link,
	  List,
	  Mention,
	  Quote,
	  Strikethrough,
	  TabIndent,
	  Toolbar: Toolbar$1,
	  Underline,
	  Video,
	  Spoiler,
	  Smiley,
	  Table,
	  Hashtag,
	  File
	};

	/**
	 * @namespace BX.UI.TextEditor.Commands
	 */
	const Commands = {
	  ...AllCommands
	};

	/**
	 * @namespace BX.UI.TextEditor.Commands
	 */
	const Constants = {
	  ...AllConstants
	};

	/**
	 * @namespace BX.UI.TextEditor.Debug
	 */
	const Debug = {
	  generateContent
	};

	exports.TextEditor = TextEditor;
	exports.BasicEditor = BasicEditor;
	exports.TextEditorComponent = TextEditorComponent;
	exports.BasicEditorComponent = BasicEditorComponent;
	exports.BasePlugin = BasePlugin;
	exports.Button = Button;
	exports.Plugins = Plugins;
	exports.Commands = Commands;
	exports.Constants = Constants;
	exports.Debug = Debug;

}((this.BX.UI.TextEditor = this.BX.UI.TextEditor || {}),BX.UI.CodeParser,BX.UI.BBCode,BX.UI.TextEditor,BX.UI.Lexical.Clipboard,BX.UI.Smiley,BX.UI.VideoService,BX.Collections,BX.UI.BBCode,BX.UI.Lexical.Selection,BX.UI.Lexical.RichText,BX.UI.Lexical.Table,BX.Event,BX.UI.Lexical.History,BX.Main,BX.Cache,BX,BX.UI.Lexical.List,BX.UI.Lexical.Link,BX.UI.Lexical.Text,BX.UI.Lexical.Core,BX.UI.Lexical.Utils,BX));
//# sourceMappingURL=text-editor.bundle.js.map

Youez - 2016 - github.com/yon3zu
LinuXploit