text: define(["exports", "../../../lit/index.js", "../../rich-text-editor/lib/toolbars/rich-text-editor-toolbar.js", "./hax-text-editor-button.js", "./hax-store.js", "./hax-context-behaviors.js", "./hax-text-editor-paste-button.js", "../../i18n-manager/lib/I18NMixin.js"], function (_exports, _index, _richTextEditorToolbar, _haxTextEditorButton, _haxStore, _haxContextBehaviors, _haxTextEditorPasteButton, _I18NMixin) {
    "use strict";
  
    Object.defineProperty(_exports, "__esModule", {
      value: true
    });
    _exports.HaxTextEditorToolbar = void 0;
  
    var _templateObject_64a1a2c0942811ecb1937969798b231a, _templateObject2_64a1a2c0942811ecb1937969798b231a;
  
    function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
  
    function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { babelHelpers.defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
  
    function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = babelHelpers.getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = babelHelpers.getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return babelHelpers.possibleConstructorReturn(this, result); }; }
  
    function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  
    /**
     * `hax-text-editor-toolbar`
     * a customized toolbar (with buttons) for HAX
     *
     * @extends RichTextEditorToolbarBehaviors
     * @extends LitElement
     * @customElement
     * @demo demo/index.html
     */
    var HaxTextEditorToolbar = /*#__PURE__*/function (_RichTextEditorToolba) {
      babelHelpers.inherits(HaxTextEditorToolbar, _RichTextEditorToolba);
  
      var _super = _createSuper(HaxTextEditorToolbar);
  
      // life cycle
      function HaxTextEditorToolbar() {
        var _this;
  
        babelHelpers.classCallCheck(this, HaxTextEditorToolbar);
        _this = _super.call(this);
        _this.tag = HaxTextEditorToolbar.tag;
        _this.t = {
          undoButton: "Undo",
          redoButton: "Redo",
          formatButton: "Format",
          blockP: "Paragraph",
          blockH1: "Heading 1",
          blockH2: "Heading 2",
          blockH3: "Heading 3",
          blockH4: "Heading 4",
          blockH5: "Heading 5",
          blockH6: "Heading 6",
          blockPre: "Preformatted",
          italicButton: "Italic",
          boldButton: "Bold",
          underlineButton: "Underline",
          strikethroughButton: "Cross out",
          codeButton: "Code",
          removeFormatButton: "Remove format",
          linkButton: "Link",
          unlinkButton: "Remove Link",
          cutButton: "Cut",
          copyButton: "Copy",
          pasteButton: "Paste Clipboard",
          subscriptButton: "Subscript",
          superscriptButton: "Superscript",
          symbolButton: "Insert Symbol",
          emojiButton: "Insert Emoticon",
          imageButton: "Insert Image",
          orderedListButton: "Bulleted list",
          unorderedListButton: "Numbered list",
          blockquoteButton: "Blockquote",
          indentButton: "Indent",
          outdentButton: "Outdent",
          textEditorToolbarTour: "Change how the text is structured and visualized in the page."
        };
  
        _this.registerLocalization({
          context: babelHelpers.assertThisInitialized(_this),
          namespace: "hax"
        });
  
        _this.sourceView = false;
        _this.haxUIElement = true;
        _this.tourName = "hax";
        window.HaxTextEditorToolbarConfig = window.HaxTextEditorToolbarConfig || {};
        window.HaxTextEditorToolbarConfig.inlineGizmos = window.HaxTextEditorToolbarConfig.inlineGizmos || {};
        window.HaxTextEditorToolbarConfig.default = window.HaxTextEditorToolbarConfig.default || babelHelpers.toConsumableArray(_this.defaultConfig);
        _this.config = window.HaxTextEditorToolbarConfig.default;
        _this.sticky = false;
        _this.__updated = false;
  
        _this.setTarget(undefined);
  
        window.addEventListener("hax-store-ready", _this._handleHaxStoreReady.bind(babelHelpers.assertThisInitialized(_this)));
        window.addEventListener("hax-register-properties", _this._handleElementRegister.bind(babelHelpers.assertThisInitialized(_this)));
        return _this;
      }
      /**
       * default config for a format button
       *
       * @readonly
       */
  
  
      babelHelpers.createClass(HaxTextEditorToolbar, [{
        key: "tourTemplate",
        get: function get() {
          return (0, _index.html)(_templateObject_64a1a2c0942811ecb1937969798b231a || (_templateObject_64a1a2c0942811ecb1937969798b231a = babelHelpers.taggedTemplateLiteral([" <div slot=\"tour\" data-stop-content>\n      ", "\n    </div>"])), this.t.textEditorToolbarTour);
        } // render function
  
      }, {
        key: "render",
        value: function render() {
          return babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "toolbarTemplate", this);
        } // properties available to the custom element for data binding
  
      }, {
        key: "tag",
        value:
        /**
         * Store the tag name to make it easier to obtain directly.
         * @notice function name must be here for tooling to operate correctly
         */
        function tag() {
          return "hax-text-editor-toolbar";
        }
      }, {
        key: "undoButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "undoButton", this)), {}, {
            label: this.t.undoButton
          });
        }
        /**
         * default config for a format button
         *
         * @readonly
         */
  
      }, {
        key: "redoButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "redoButton", this)), {}, {
            label: this.t.redoButton
          });
        }
        /**
         * default config for a format button
         *
         * @readonly
         */
  
      }, {
        key: "formatButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "formatButton", this)), {}, {
            label: this.t.formatButton,
            blocks: this.formatBlocks
          });
        }
      }, {
        key: "formatBlocks",
        get: function get() {
          return [{
            label: this.t.blockP,
            tag: "p"
          }, {
            label: this.t.blockH1,
            tag: "h1"
          }, {
            label: this.t.blockH2,
            tag: "h2"
          }, {
            label: this.t.blockH3,
            tag: "h3"
          }, {
            label: this.t.blockH4,
            tag: "h4"
          }, {
            label: this.t.blockH5,
            tag: "h5"
          }, {
            label: this.t.blockH6,
            tag: "h6"
          }, {
            label: this.t.blockPre,
            tag: "pre"
          }];
        }
        /**
         * default config for a bold button
         *
         * @readonly
         */
  
      }, {
        key: "boldButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "boldButton", this)), {}, {
            label: this.t.boldButton
          });
        }
        /**
         * default config for an italic button
         *
         * @readonly
         */
  
      }, {
        key: "italicButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "italicButton", this)), {}, {
            label: this.t.italicButton
          });
        }
        /**
         * default config for an underline button
         *
         * @readonly
         */
  
      }, {
        key: "underlineButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "underlineButton", this)), {}, {
            label: this.t.underlineButton
          });
        }
        /**
         * default config for an underline button
         *
         * @readonly
         */
  
      }, {
        key: "strikethroughButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "strikethroughButton", this)), {}, {
            label: this.t.strikethroughButton
          });
        }
        /**
         * default config for a <code></code> button
         *
         * @readonly
         */
  
      }, {
        key: "codeButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "codeButton", this)), {}, {
            icon: "hax:html-code",
            label: this.t.codeButton
          });
        }
        /**
         * default config for a remove format button
         *
         * @readonly
         */
  
      }, {
        key: "removeFormatButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "removeFormatButton", this)), {}, {
            label: this.t.removeFormatButton
          });
        }
        /**
         * default config for a style button group: format, bold, italic, and remove format
         *
         * @readonly
         */
  
      }, {
        key: "advancedInlineButtonGroup",
        get: function get() {
          return {
            type: "button-group",
            subtype: "advanced-inline-button-group",
            buttons: [this.underlineButton, this.strikethroughButton, this.codeButton]
          };
        }
        /**
         * default config for a link button
         *
         * @readonly
         */
  
      }, {
        key: "linkButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "linkButton", this)), {}, {
            label: this.t.linkButton,
            allowTarget: !!_haxStore.HAXStore.activeHaxBody && !!_haxStore.HAXStore.activeHaxBody.allowLinkTarget
          });
        }
        /**
         * default config for a link button
         *
         * @readonly
         */
  
      }, {
        key: "unlinkButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "unlinkButton", this)), {}, {
            label: this.t.unlinkButton
          });
        }
        /**
         * default config for a cut button
         *
         * @readonly
         */
  
      }, {
        key: "cutButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "cutButton", this)), {}, {
            label: this.t.cutButton
          });
        }
        /**
         * default config for a copy button
         *
         * @readonly
         */
  
      }, {
        key: "copyButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "copyButton", this)), {}, {
            label: this.t.copyButton
          });
        }
        /**
         * default config for a paste button
         *
         * @readonly
         */
  
      }, {
        key: "pasteButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "pasteButton", this)), {}, {
            label: this.t.pasteButton,
            shortcutKeys: undefined,
            type: "hax-text-editor-paste-button"
          });
        }
        /**
         * default config for a subscript button
         *
         * @readonly
         */
  
      }, {
        key: "subscriptButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "subscriptButton", this)), {}, {
            label: this.t.subscriptButton
          });
        }
        /**
         * default config for a superscript button
         *
         * @readonly
         */
  
      }, {
        key: "superscriptButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "superscriptButton", this)), {}, {
            label: this.t.superscriptButton
          });
        }
        /**
         * default config for a symbol button
         *
         * @readonly
         */
  
      }, {
        key: "symbolButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "symbolButton", this)), {}, {
            label: this.t.symbolButton
          });
        }
        /**
         * default config for an emoji button
         *
         * @readonly
         */
  
      }, {
        key: "emojiButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "emojiButton", this)), {}, {
            label: this.t.emojiButton
          });
        }
        /**
         * default config for an image button
         *
         * @readonly
         */
  
      }, {
        key: "imageButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "imageButton", this)), {}, {
            label: this.t.imageButton
          });
        }
        /**
         * default config for an ordered list button
         *
         * @readonly
         */
  
      }, {
        key: "orderedListButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "orderedListButton", this)), {}, {
            label: this.t.orderedListButton
          });
        }
        /**
         * default config for an unordered list button
         *
         * @readonly
         */
  
      }, {
        key: "unorderedListButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "unorderedListButton", this)), {}, {
            label: this.t.unorderedListButton
          });
        }
        /**
         * default config for a blockquote button
         *
         * @readonly
         */
  
      }, {
        key: "blockquoteButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "blockquoteButton", this)), {}, {
            label: this.t.blockquoteButton
          });
        }
        /**
         * default config for an indent button
         *
         * @readonly
         */
  
      }, {
        key: "indentButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "indentButton", this)), {}, {
            label: this.t.indentButton
          });
        }
        /**
         * default config for an outdent button
         *
         * @readonly
         */
  
      }, {
        key: "outdentButton",
        get: function get() {
          return _objectSpread(_objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "outdentButton", this)), {}, {
            label: this.t.outdentButton
          });
        }
        /**
         * default config for a view source button
         *
         * @readonly
         */
  
      }, {
        key: "sourceButton",
        get: function get() {
          return _objectSpread({}, babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "sourceButton", this));
        }
      }, {
        key: "haxSymbolInsertButtonGroup",
        get: function get() {
          return {
            type: "button-group",
            subtype: "hax-symbol-insert-button-group",
            buttons: [this.symbolButton, this.emojiButton]
          };
        }
      }, {
        key: "iconButton",
        get: function get() {
          return {};
        }
      }, {
        key: "defaultConfig",
        get: function get() {
          return [this.basicInlineButtonGroup, this.linkButtonGroup, this.listIndentButtonGroup, this.scriptButtonGroup, this.haxSymbolInsertButtonGroup, this.advancedInlineButtonGroup];
        }
      }, {
        key: "filteredBlocks",
        get: function get() {
          return this.getFilteredBlocks(this.formatBlocks);
        }
      }, {
        key: "formatButtonElement",
        get: function get() {
          return this.formatButton.type ? this.querySelector(this.formatButton.type) : undefined;
        }
        /**
         * determines if current range is in scope of the target
         * overrides default behavior so that the entire target can be selected
         *
         * @readonly
         */
  
      }, {
        key: "isRangeInScope",
        get: function get() {
          return this.range && this.target && this.rangeNodeOrParentNode(this.range) && (this.range.commonAncestorContainer === this.target || this.target.contains(this.range.commonAncestorContainer));
        }
        /**
         * list of event handlers for a given target
         *
         * @param {*} target
         * @returns
         */
  
      }, {
        key: "targetHandlers",
        value: function targetHandlers(target) {
          var handlers = babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "targetHandlers", this).call(this, target);
          delete handlers.paste;
          return handlers;
        }
      }, {
        key: "updated",
        value: function updated(changedProperties) {
          var _this2 = this;
  
          if (babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "updated", this)) babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "updated", this).call(this, changedProperties);
  
          if (this.__ready) {
            changedProperties.forEach(function (oldValue, propName) {
              if (propName === "parentSchema" || propName === "target") _this2.updateBlocks();
              if (propName === "activeNode" && _this2.activeNode !== oldValue) _this2.setTarget(_this2.activeNode);
              if (propName === "t" && _this2.t !== oldValue) _this2.updateToolbarElements();
            });
          }
        }
      }, {
        key: "firstUpdated",
        value: function firstUpdated(changedProperties) {
          if (babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "firstUpdated", this)) babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar.prototype), "firstUpdated", this).call(this, changedProperties);
          this.config = this.updateToolbarElements();
          this.__prompt.haxUIElement = true;
  
          this.__prompt.classList.add("ignore-activation");
  
          this.addEventListener("keypress", this.trapKeys.bind(this));
  
          this.__prompt.addEventListener("keypress", this.trapKeys.bind(this));
  
          this.__prompt.addEventListener("paste", this._handlePaste.bind(this));
        }
        /**
         * keeps keys from HAX
         *
         * @param {*} e
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "_handlePaste",
        value: function _handlePaste(e) {
          e.stopPropagation();
        }
        /**
         * keeps keys from HAX
         *
         * @param {*} e
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "trapKeys",
        value: function trapKeys(e) {
          e.stopPropagation();
        }
      }, {
        key: "updateBlocks",
        value: function updateBlocks() {
          var filter = this.filteredBlocks;
  
          if (this.formatButtonElement && this.formatButtonElement.blocks !== filter) {
            this.formatButtonElement.blocks = filter;
  
            if (filter.length < 2) {
              this.formatButtonElement.setAttribute("disabled", "disabled");
            } else {
              this.formatButtonElement.removeAttribute("disabled");
            }
          }
        }
      }, {
        key: "getRange",
        value: function getRange() {
          var range = _haxStore.HAXStore.getRange();
  
          return !range || range.rangeCount < 1 ? undefined : _haxStore.HAXStore.getRange();
        }
      }, {
        key: "getSelection",
        value: function getSelection() {
          return _haxStore.HAXStore.getSelection();
        }
        /**
         * moves toolbar into position before the target
         * (can be overriden for custom positioning)
         * @param {object} target
         */
  
      }, {
        key: "positionByTarget",
        value: function positionByTarget(target) {
          return;
        }
        /**
         * when an element is registered,
         * check its properties
         *
         * @param {event} e
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "_handleElementRegister",
        value: function _handleElementRegister(e) {
          var detail = e.detail || {},
              tag = detail.tag || {},
              props = detail.properties || {};
  
          this._setInlineElement(tag, props);
        }
        /**
         * when hax-store is ready,
         * check its registered elements
         *
         * @param {event} e
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "_handleHaxStoreReady",
        value: function _handleHaxStoreReady(e) {
          var _this3 = this;
  
          this.__ready = true;
          var elements = _haxStore.HAXStore.elementList || {},
              keys = Object.keys(elements);
          keys.forEach(function (key) {
            return _this3._setInlineElement(key, elemets[key]);
          });
        }
        /**
         * if an an element is inline,
         * adds it to list of inline elements
         *
         * @param {*} tag
         * @param {*} props
         * @returns
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "_setInlineElement",
        value: function _setInlineElement(tag, props) {
          var _this4 = this;
  
          //skip if tag is already registered
          if (!tag || !props || !!window.HaxTextEditorToolbarConfig.inlineGizmos[tag] || tag.indexOf("-") < 0) return;
  
          var element = _objectSpread({}, props),
              gizmo = props.gizmo || {},
              title = tag.replace(/-./g, function (x) {
            return x.toUpperCase()[1];
          }),
              custom = tag.split("-").length > 1,
              meta = gizmo.meta || {},
              inlineOnly = meta.inlineOnly,
              handles = gizmo.handles || [],
              handlesInline = handles.filter(function (handle) {
            return handle.type === "inline";
          }).length > 1,
              inline = custom && (inlineOnly || handlesInline);
  
          if (!element.gizmo.title) element.gizmo.title = title;
  
          if (inline) {
            window.HaxTextEditorToolbarConfig.inlineGizmos[tag] = {
              element: element,
              type: "hax-text-editor-button"
            };
            this.__updated = false;
            setTimeout(function (e) {
              return _this4.config = _this4.updateToolbarElements();
            }, 500);
          }
        }
        /**
         * updates the toolbar buttons
         * to include custom inline element buttons
         *
         * @returns
         * @memberof HaxTextEditorToolbar
         */
  
      }, {
        key: "updateToolbarElements",
        value: function updateToolbarElements() {
          if (this.__updated) return;
          this.__updated = true;
          var buttons = Object.keys(window.HaxTextEditorToolbarConfig.inlineGizmos || {}).map(function (key) {
            return window.HaxTextEditorToolbarConfig.inlineGizmos[key];
          });
          return buttons.length === 0 ? babelHelpers.toConsumableArray(this.defaultConfig || []) : [].concat(babelHelpers.toConsumableArray(this.defaultConfig || []), [{
            type: "button-group",
            subtype: "hax-insert-button-group",
            buttons: buttons
          }]);
        }
      }], [{
        key: "styles",
        get: //styles function
        function get() {
          return [].concat(babelHelpers.toConsumableArray(babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar), "baseStyles", this)), babelHelpers.toConsumableArray(babelHelpers.get(babelHelpers.getPrototypeOf(HaxTextEditorToolbar), "stickyStyles", this)), [(0, _index.css)(_templateObject2_64a1a2c0942811ecb1937969798b231a || (_templateObject2_64a1a2c0942811ecb1937969798b231a = babelHelpers.taggedTemplateLiteral(["\n        :host {\n          --rich-text-editor-button-color: var(--hax-ui-color);\n          --rich-text-editor-button-bg: var(--hax-ui-background-color);\n          --rich-text-editor-button-border-color: transparent;\n          --rich-text-editor-button-hover-color: var(--hax-ui-color);\n          --rich-text-editor-button-hover-bg: var(\n            --hax-ui-background-color-secondary\n          );\n          --rich-text-editor-button-toggled-color: var(--hax-ui-color-accent);\n          --rich-text-editor-button-toggled-bg: var(--hax-ui-background-color);\n          --rich-text-editor-button-toggled-border-color: var(\n            --hax-ui-color-accent\n          );\n          --rich-text-editor-button-disabled-opacity: 1;\n          --rich-text-editor-button-disabled-color: var(\n            --hax-ui-disabled-color\n          );\n          --rich-text-editor-button-disabled-bg: var(--hax-ui-background-color);\n          --rich-text-editor-button-disabled-border-color: transparent;\n        }\n        #morebutton {\n          align-self: flex-end;\n        }\n        ::slotted([icon-position]:hover) {\n          --rich-text-editor-button-toggled-bg: var(\n            --hax-ui-background-color-accent\n          );\n        }\n        ::slotted(.group) {\n          flex: 0 0 auto;\n          justify-content: center;\n          border-width: 1px;\n          margin: -1px;\n          padding: 0px;\n        }\n        ::slotted(.group),\n        ::slotted([icon-position]) {\n          z-index: 1;\n        }\n        ::slotted([icon-position]),\n        :host([collapsed]) ::slotted(.group) {\n          flex: 0 0 auto;\n        }\n        :host ::slotted(*:focus),\n        :host ::slotted(*:focus-within) {\n          z-index: 2 !important;\n        }\n        :host ::slotted(*:hover) {\n          z-index: 3 !important;\n        }\n      "])))]);
        }
      }, {
        key: "properties",
        get: function get() {
          return {
            __updated: {
              type: Boolean
            }
          };
        }
      }]);
      return HaxTextEditorToolbar;
    }((0, _richTextEditorToolbar.RichTextEditorToolbarBehaviors)((0, _I18NMixin.I18NMixin)((0, _haxContextBehaviors.HaxContextBehaviors)(_index.LitElement))));
  
    _exports.HaxTextEditorToolbar = HaxTextEditorToolbar;
    customElements.define("hax-text-editor-toolbar", HaxTextEditorToolbar);
  });