@wrrdev/fenix-ui 1.1.13 → 1.1.15

package/dist/components/editor/editor.js

@@ -0,0 +1,1951 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _built, _eventsBound, _initialized, _defaultValue, _value, _dirty, _sourceMode, _lastRange, _rafId, _emitTimer, _lastLimitError, _snapshotTimer, _history, _historyIndex, _imagePicker, _mediaFigure, _linkAnchor, _resizeDispose, _dialogReturnFocus, _dialogResolve, _disposers, _selectionRaf, _bodyOverflow, _FxEditor_instances, on_fn, bindEvents_fn, syncChrome_fn, applyCssVars_fn, updateEmpty_fn, updateCount_fn, fits_fn, limitError_fn, validate_fn, cleanHtml_fn, serialize_fn, applyValue_fn, scheduleEmit_fn, emitNow_fn, emitChange_fn, pushHistory_fn, scheduleSnapshot_fn, historyUndo_fn, historyRedo_fn, bindGlobalSelection_fn, restoreSelection_fn, syncBodyOverflow_fn, updateSourceUi_fn, releaseDialog_fn, renderToolbar_fn, updateToolbar_fn, handleToolbarKeydown_fn, moveToolbarTabStop_fn, trapDialogFocus_fn, execCommand_fn, afterCommand_fn, action_fn, handleKeydown_fn, tabInTable_fn, handleBeforeInput_fn, handlePaste_fn, handleDrop_fn, insertPlainText_fn, toggleSource_fn, applySource_fn, cancelSource_fn, openDialog_fn, fieldHtml_fn, submitDialog_fn, openLinkDialog_fn, openImageDialog_fn, toEmbedUrl_fn, openVideoDialog_fn, decorateMediaFigures_fn, syncQuickActions_fn, selectAnchor_fn, handleLinkOverlayClick_fn, openLink_fn, removeLink_fn, showLinkOverlay_fn, hideLinkOverlay_fn, positionLinkOverlay_fn, handleEditorClick_fn, showMediaOverlay_fn, hideMediaOverlay_fn, deleteMediaFigure_fn, positionMediaOverlay_fn, startResize_fn, endResize_fn, handleDoubleClick_fn, insertImage_fn, insertVideo_fn, insertEmbed_fn, insertTable_fn, insertColumns_fn, showTablePanel_fn, showColumnsPanel_fn, hidePanel_fn, currentTable_fn, tableAction_fn, handleImageFile_fn, fileToDataUrl_fn, error_fn;
+import { FxFormElement } from "../../core/form-element.js";
+import { defineElement } from "../../core/define.js";
+import { esc } from "../../core/sanitize.js";
+import { FENIX_ICON_BASE_CSS, fenixIconHtml } from "../../icons/base-css.js";
+import { loadFenixIconsFont } from "../../icons/font.js";
+import { sanitizeBody, sanitizeLinkUrl, sanitizeMediaUrl, sanitizeEmbedUrl } from "./sanitize-html.js";
+import { normalizeElement } from "./normalize-html.js";
+import { EDITOR_STYLES } from "./styles.js";
+import { saveRange, getRange, placeCaretAtEnd, restoreRange, getBlock, closestInEditor } from "./selection.js";
+import { formatBlock, nativeExec, insertHtml, removeFormat, toggleList, align, toggleInline, unlink, indent, escapeText, applyLink, escapeAttr } from "./commands.js";
+import { mergeSelectedCells, splitCell } from "./table-utils.js";
+const MAX_PASTE_BYTES = 1024 * 1024;
+const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+const LARGE_DOC_CHARS = 2e4;
+const EMIT_DEBOUNCE_MS = 140;
+const HISTORY_LIMIT = 50;
+const QUICK_SVG = {
+  left: '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M4 6h16M4 10h10M4 14h16M4 18h10"/></svg>',
+  center: '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M4 6h16M7 10h10M4 14h16M7 18h10"/></svg>',
+  right: '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M4 6h16M10 10h10M4 14h16M10 18h10"/></svg>',
+  delete: '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 6h18M8 6V4h8v2M6 6l1 15h10l1-15M10 10v7M14 10v7"/></svg>'
+};
+const _FxEditor = class _FxEditor extends FxFormElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _FxEditor_instances);
+    __privateAdd(this, _built, false);
+    __privateAdd(this, _eventsBound, false);
+    __privateAdd(this, _initialized, false);
+    __privateAdd(this, _defaultValue, "");
+    __privateAdd(this, _value, "");
+    __privateAdd(this, _dirty, false);
+    __privateAdd(this, _sourceMode, false);
+    __privateAdd(this, _lastRange, null);
+    __privateAdd(this, _rafId, 0);
+    __privateAdd(this, _emitTimer, null);
+    __privateAdd(this, _lastLimitError, 0);
+    __privateAdd(this, _snapshotTimer, null);
+    __privateAdd(this, _history, []);
+    __privateAdd(this, _historyIndex, -1);
+    __privateAdd(this, _imagePicker, null);
+    __privateAdd(this, _mediaFigure, null);
+    __privateAdd(this, _linkAnchor, null);
+    __privateAdd(this, _resizeDispose, null);
+    __privateAdd(this, _dialogReturnFocus, null);
+    __privateAdd(this, _dialogResolve, null);
+    __privateAdd(this, _disposers, []);
+    __privateAdd(this, _selectionRaf, 0);
+    __privateAdd(this, _bodyOverflow, "");
+  }
+  static get observedAttributes() {
+    return [
+      "toolbar",
+      "features",
+      "placeholder",
+      "readonly",
+      "disabled",
+      "required",
+      "full",
+      "error",
+      "invalid",
+      "success",
+      "valid",
+      "show-count",
+      "paste-mode",
+      "min-height",
+      "max-height",
+      "fullscreen",
+      "maxlength"
+    ];
+  }
+  get editor() {
+    return this.root.querySelector(".content");
+  }
+  get source() {
+    return this.root.querySelector(".source");
+  }
+  get toolbarEl() {
+    return this.root.querySelector(".toolbar");
+  }
+  get value() {
+    if (__privateGet(this, _sourceMode) && this.source) return __privateMethod(this, _FxEditor_instances, serialize_fn).call(this);
+    if (__privateGet(this, _dirty)) __privateSet(this, _value, __privateMethod(this, _FxEditor_instances, serialize_fn).call(this));
+    return __privateGet(this, _value);
+  }
+  set value(next) {
+    const clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, next ?? "");
+    __privateSet(this, _value, clean);
+    __privateSet(this, _dirty, false);
+    if (!__privateGet(this, _defaultValue)) __privateSet(this, _defaultValue, clean);
+    __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, clean);
+    this.updateFormValue();
+  }
+  get html() {
+    return this.value;
+  }
+  set html(next) {
+    this.value = next;
+  }
+  get text() {
+    return (this.editor?.textContent ?? "").replace(/\u200b/g, "").trim();
+  }
+  get defaultValue() {
+    return __privateGet(this, _defaultValue);
+  }
+  set defaultValue(next) {
+    __privateSet(this, _defaultValue, __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, next ?? ""));
+    if (!__privateGet(this, _dirty)) this.value = __privateGet(this, _defaultValue);
+  }
+  get disabled() {
+    return this.hasAttr("disabled");
+  }
+  set disabled(value) {
+    this.toggleAttr("disabled", Boolean(value));
+  }
+  get readonly() {
+    return this.hasAttr("readonly");
+  }
+  set readonly(value) {
+    this.toggleAttr("readonly", Boolean(value));
+  }
+  get required() {
+    return this.hasAttr("required");
+  }
+  set required(value) {
+    this.toggleAttr("required", Boolean(value));
+  }
+  get placeholder() {
+    return this.getAttr("placeholder");
+  }
+  set placeholder(value) {
+    this.setAttribute("placeholder", value);
+  }
+  get toolbar() {
+    const value = this.getAttr("toolbar", "standard");
+    return ["minimal", "basic", "standard", "full", "none"].includes(value) ? value : "standard";
+  }
+  set toolbar(value) {
+    this.setAttribute("toolbar", value);
+  }
+  get pasteMode() {
+    return this.getAttr("paste-mode", "clean") === "plain" ? "plain" : "clean";
+  }
+  set pasteMode(value) {
+    this.setAttribute("paste-mode", value);
+  }
+  get fullscreen() {
+    return this.hasAttr("fullscreen");
+  }
+  set fullscreen(value) {
+    this.toggleAttr("fullscreen", Boolean(value));
+  }
+  /** Limite de caracteres de texto (0 desativa). Padrão: 30.000. */
+  get maxlength() {
+    const value = Number.parseInt(this.getAttr("maxlength", "30000"), 10);
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  }
+  set maxlength(value) {
+    if (Number.isFinite(value) && value >= 0) this.setAttribute("maxlength", String(Math.floor(value)));
+    else this.removeAttribute("maxlength");
+  }
+  connectedCallback() {
+    loadFenixIconsFont();
+    super.connectedCallback();
+    if (this.fullscreen) __privateMethod(this, _FxEditor_instances, syncBodyOverflow_fn).call(this);
+    if (!__privateGet(this, _initialized)) {
+      __privateSet(this, _initialized, true);
+      const initial = __privateGet(this, _value) || this.getAttr("value") || this.innerHTML;
+      this.replaceChildren();
+      __privateSet(this, _defaultValue, __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, initial));
+      __privateSet(this, _value, __privateGet(this, _defaultValue));
+      __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, __privateGet(this, _defaultValue));
+      this.updateFormValue();
+      __privateMethod(this, _FxEditor_instances, pushHistory_fn).call(this, __privateGet(this, _value));
+      this.dispatchEvent(new CustomEvent("ready", { bubbles: true, composed: true }));
+    } else if (__privateGet(this, _built) && !__privateGet(this, _eventsBound)) {
+      __privateMethod(this, _FxEditor_instances, bindEvents_fn).call(this);
+      __privateSet(this, _eventsBound, true);
+    }
+    __privateMethod(this, _FxEditor_instances, bindGlobalSelection_fn).call(this);
+  }
+  disconnectedCallback() {
+    for (const dispose of __privateGet(this, _disposers)) dispose();
+    __privateSet(this, _disposers, []);
+    __privateSet(this, _eventsBound, false);
+    cancelAnimationFrame(__privateGet(this, _rafId));
+    cancelAnimationFrame(__privateGet(this, _selectionRaf));
+    if (__privateGet(this, _emitTimer)) clearTimeout(__privateGet(this, _emitTimer));
+    if (__privateGet(this, _snapshotTimer)) clearTimeout(__privateGet(this, _snapshotTimer));
+    __privateMethod(this, _FxEditor_instances, endResize_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+    if (this.hasAttr("fullscreen")) document.body.style.overflow = __privateGet(this, _bodyOverflow);
+    __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, null);
+    super.disconnectedCallback();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (oldValue === newValue || !__privateGet(this, _built)) return;
+    if (name === "toolbar" || name === "features") __privateMethod(this, _FxEditor_instances, renderToolbar_fn).call(this);
+    if (name === "fullscreen") __privateMethod(this, _FxEditor_instances, syncBodyOverflow_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, syncChrome_fn).call(this);
+  }
+  formResetCallback() {
+    __privateSet(this, _dirty, false);
+    this.value = __privateGet(this, _defaultValue);
+  }
+  getFormValue() {
+    return this.hasAttr("disabled") ? null : this.value;
+  }
+  render() {
+    if (__privateGet(this, _built)) return;
+    this.setTemplate(`
+      <div class="editor" part="editor">
+        <div class="toolbar" part="toolbar" role="toolbar" aria-label="Formatação" aria-orientation="horizontal"></div>
+        <div class="body">
+          <div class="content" part="content" contenteditable="true" role="textbox"
+               aria-multiline="true" spellcheck="true"></div>
+          <textarea class="source" part="source" spellcheck="false" hidden aria-label="HTML do conteúdo"></textarea>
+          <div class="media-overlay" part="media-overlay" hidden>
+            <span class="media-handle nw" data-handle="nw"></span>
+            <span class="media-handle ne" data-handle="ne"></span>
+            <span class="media-handle sw" data-handle="sw"></span>
+            <span class="media-handle se" data-handle="se"></span>
+            <span class="media-size"></span>
+            <button type="button" class="media-delete" data-media-action="delete" aria-label="Excluir mídia" title="Excluir mídia">${fenixIconHtml("delete")}</button>
+          </div>
+          <div class="link-overlay" part="link-overlay" hidden>
+            <button type="button" data-link-action="open">Abrir</button>
+            <button type="button" data-link-action="edit">Editar</button>
+            <button type="button" data-link-action="remove">Remover</button>
+          </div>
+        </div>
+        <div class="statusbar" part="statusbar">
+          <span class="count"></span>
+          <span class="source-actions" hidden>
+            <button type="button" class="btn source-apply">Aplicar</button>
+            <button type="button" class="btn source-cancel">Cancelar</button>
+          </span>
+          <slot name="footer"></slot>
+        </div>
+        <input type="file" class="image-picker" accept="image/*" hidden>
+        <div class="backdrop" part="dialog" hidden>
+          <div class="dialog" role="dialog" aria-modal="true" aria-labelledby="fx-editor-dialog-title">
+            <header>
+              <h3 id="fx-editor-dialog-title"></h3>
+              <button type="button" class="dialog-close" aria-label="Fechar">×</button>
+            </header>
+            <div class="dialog-body"></div>
+            <footer>
+              <button type="button" class="btn dialog-cancel">Cancelar</button>
+              <button type="button" class="btn dialog-ok">Aplicar</button>
+            </footer>
+          </div>
+        </div>
+      </div>
+    `);
+    __privateSet(this, _built, true);
+    __privateSet(this, _imagePicker, this.root.querySelector(".image-picker"));
+    __privateMethod(this, _FxEditor_instances, bindEvents_fn).call(this);
+    __privateSet(this, _eventsBound, true);
+    __privateMethod(this, _FxEditor_instances, renderToolbar_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, syncChrome_fn).call(this);
+  }
+  /* ---------------------------------------------------------------------
+   * API pública
+   * ------------------------------------------------------------------ */
+  focus(options) {
+    this.editor?.focus(options ?? { preventScroll: true });
+  }
+  blur() {
+    this.editor?.blur();
+  }
+  execute(command, value) {
+    if (value !== void 0) {
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      nativeExec("styleWithCSS", "true");
+      nativeExec(command, value);
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      return;
+    }
+    __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, command);
+  }
+  insertHTML(html) {
+    const clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, html);
+    const probe = document.createElement("div");
+    probe.innerHTML = clean;
+    const extra = probe.textContent?.length ?? 0;
+    if (!__privateMethod(this, _FxEditor_instances, fits_fn).call(this, extra)) {
+      __privateMethod(this, _FxEditor_instances, limitError_fn).call(this);
+      return;
+    }
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+    insertHtml(this.editor, clean);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  }
+  /** Mescla as células tocadas pela seleção. */
+  mergeCells() {
+    const table = __privateMethod(this, _FxEditor_instances, currentTable_fn).call(this);
+    const editor = this.editor;
+    const range = editor ? getRange(editor, __privateGet(this, _lastRange)) : null;
+    if (!table || !range) return false;
+    const merged = mergeSelectedCells(table, range);
+    if (!merged) return false;
+    placeCaretAtEnd(merged);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    return true;
+  }
+  /** Divide a célula mesclada atual. */
+  splitCell() {
+    const table = __privateMethod(this, _FxEditor_instances, currentTable_fn).call(this);
+    const editor = this.editor;
+    const range = editor ? getRange(editor, __privateGet(this, _lastRange)) : null;
+    const cell = editor ? closestInEditor(editor, range?.startContainer ?? null, "td,th") : null;
+    if (!table || !cell) return false;
+    const created = splitCell(table, cell);
+    if (!created.length) return false;
+    placeCaretAtEnd(cell);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    return true;
+  }
+  getHtml() {
+    return this.value;
+  }
+  setHtml(html) {
+    this.value = html;
+  }
+  getText() {
+    return this.text;
+  }
+  clear() {
+    this.value = "";
+    __privateSet(this, _dirty, false);
+    __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, "");
+    this.updateFormValue();
+    __privateMethod(this, _FxEditor_instances, emitChange_fn).call(this);
+    this.focus();
+  }
+  undo() {
+    this.execute("undo");
+  }
+  redo() {
+    this.execute("redo");
+  }
+  saveSelection() {
+    if (this.editor) __privateSet(this, _lastRange, saveRange(this.editor) ?? __privateGet(this, _lastRange));
+  }
+  restoreSelection() {
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  }
+  openDialog(kind) {
+    if (kind === "link") void __privateMethod(this, _FxEditor_instances, openLinkDialog_fn).call(this);
+    else if (kind === "image") void __privateMethod(this, _FxEditor_instances, openImageDialog_fn).call(this);
+    else void __privateMethod(this, _FxEditor_instances, openVideoDialog_fn).call(this);
+  }
+  toggleSource() {
+    __privateMethod(this, _FxEditor_instances, toggleSource_fn).call(this);
+  }
+  toggleFullscreen() {
+    this.fullscreen = !this.fullscreen;
+  }
+};
+_built = new WeakMap();
+_eventsBound = new WeakMap();
+_initialized = new WeakMap();
+_defaultValue = new WeakMap();
+_value = new WeakMap();
+_dirty = new WeakMap();
+_sourceMode = new WeakMap();
+_lastRange = new WeakMap();
+_rafId = new WeakMap();
+_emitTimer = new WeakMap();
+_lastLimitError = new WeakMap();
+_snapshotTimer = new WeakMap();
+_history = new WeakMap();
+_historyIndex = new WeakMap();
+_imagePicker = new WeakMap();
+_mediaFigure = new WeakMap();
+_linkAnchor = new WeakMap();
+_resizeDispose = new WeakMap();
+_dialogReturnFocus = new WeakMap();
+_dialogResolve = new WeakMap();
+_disposers = new WeakMap();
+_selectionRaf = new WeakMap();
+_bodyOverflow = new WeakMap();
+_FxEditor_instances = new WeakSet();
+on_fn = function(target, type, handler, options) {
+  target.addEventListener(type, handler, options);
+  __privateGet(this, _disposers).push(() => target.removeEventListener(type, handler, options));
+};
+bindEvents_fn = function() {
+  const editor = this.editor;
+  const toolbar = this.toolbarEl;
+  if (!editor || !toolbar) return;
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "mousedown", (event) => {
+    const target = event.target;
+    __privateSet(this, _lastRange, saveRange(editor) ?? __privateGet(this, _lastRange));
+    __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+    if (target.closest("button")) event.preventDefault();
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "click", (event) => {
+    const target = event.target.closest("[data-cmd],[data-action]");
+    if (!target || target.disabled) return;
+    const cmd = target.dataset.cmd;
+    const action = target.dataset.action;
+    if (cmd) __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, cmd);
+    else if (action) __privateMethod(this, _FxEditor_instances, action_fn).call(this, action);
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "change", (event) => {
+    const select = event.target.closest("[data-block]");
+    if (!select) return;
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+    formatBlock(editor, select.value || "p");
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "input", (event) => {
+    const input = event.target.closest("[data-color]");
+    if (!input) return;
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+    nativeExec("styleWithCSS", "true");
+    nativeExec(input.dataset.color ?? "foreColor", input.value);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "keydown", (event) => __privateMethod(this, _FxEditor_instances, handleToolbarKeydown_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, toolbar, "focusin", (event) => {
+    const button = event.target.closest(".tb-btn");
+    if (button) __privateMethod(this, _FxEditor_instances, moveToolbarTabStop_fn).call(this, button);
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "input", (event) => {
+    event.stopPropagation();
+    __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+    __privateSet(this, _dirty, true);
+    __privateMethod(this, _FxEditor_instances, updateEmpty_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, scheduleEmit_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, scheduleSnapshot_fn).call(this);
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "focus", () => {
+    this.dispatchEvent(new CustomEvent("focus", { bubbles: true, composed: true }));
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "blur", () => {
+    __privateSet(this, _lastRange, saveRange(editor) ?? __privateGet(this, _lastRange));
+    __privateMethod(this, _FxEditor_instances, emitNow_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, emitChange_fn).call(this);
+    this.dispatchEvent(new CustomEvent("blur", { bubbles: true, composed: true }));
+  });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "keydown", (event) => __privateMethod(this, _FxEditor_instances, handleKeydown_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "beforeinput", (event) => __privateMethod(this, _FxEditor_instances, handleBeforeInput_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "paste", (event) => __privateMethod(this, _FxEditor_instances, handlePaste_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "dragover", (event) => event.preventDefault());
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "drop", (event) => __privateMethod(this, _FxEditor_instances, handleDrop_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "dblclick", (event) => __privateMethod(this, _FxEditor_instances, handleDoubleClick_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "click", (event) => __privateMethod(this, _FxEditor_instances, handleEditorClick_fn).call(this, event));
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, editor, "scroll", () => {
+    __privateMethod(this, _FxEditor_instances, positionMediaOverlay_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, positionLinkOverlay_fn).call(this);
+  }, { passive: true });
+  __privateMethod(this, _FxEditor_instances, on_fn).call(this, window, "resize", () => {
+    __privateMethod(this, _FxEditor_instances, positionMediaOverlay_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, positionLinkOverlay_fn).call(this);
+  });
+  const overlay = this.root.querySelector(".media-overlay");
+  if (overlay) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, overlay, "pointerdown", (event) => __privateMethod(this, _FxEditor_instances, startResize_fn).call(this, event));
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, overlay, "click", (event) => {
+      const action = event.target.closest("[data-media-action]");
+      if (action?.dataset.mediaAction === "delete") __privateMethod(this, _FxEditor_instances, deleteMediaFigure_fn).call(this);
+    });
+  }
+  const linkOverlay = this.root.querySelector(".link-overlay");
+  if (linkOverlay) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, linkOverlay, "click", (event) => __privateMethod(this, _FxEditor_instances, handleLinkOverlayClick_fn).call(this, event));
+  }
+  if (this.source) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, this.source, "input", () => {
+      __privateSet(this, _dirty, true);
+      __privateMethod(this, _FxEditor_instances, scheduleEmit_fn).call(this);
+    });
+  }
+  if (__privateGet(this, _imagePicker)) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, __privateGet(this, _imagePicker), "change", () => {
+      const file = __privateGet(this, _imagePicker)?.files?.[0];
+      if (file) void __privateMethod(this, _FxEditor_instances, handleImageFile_fn).call(this, file);
+      if (__privateGet(this, _imagePicker)) __privateGet(this, _imagePicker).value = "";
+    });
+  }
+  const backdrop = this.root.querySelector(".backdrop");
+  if (backdrop) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, backdrop, "click", (event) => {
+      if (event.target === backdrop) __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, null);
+    });
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, backdrop, "keydown", (event) => __privateMethod(this, _FxEditor_instances, trapDialogFocus_fn).call(this, event));
+  }
+  const dialogBody = this.root.querySelector(".dialog-body");
+  if (dialogBody) {
+    __privateMethod(this, _FxEditor_instances, on_fn).call(this, dialogBody, "keydown", (event) => {
+      const target = event.target;
+      if (event.key === "Enter" && target.tagName !== "BUTTON") {
+        event.preventDefault();
+        __privateMethod(this, _FxEditor_instances, submitDialog_fn).call(this);
+      }
+    });
+  }
+  for (const selector of [".dialog-close", ".dialog-cancel"]) {
+    const btn = this.root.querySelector(selector);
+    if (btn) __privateMethod(this, _FxEditor_instances, on_fn).call(this, btn, "click", () => __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, null));
+  }
+  const ok = this.root.querySelector(".dialog-ok");
+  if (ok) __privateMethod(this, _FxEditor_instances, on_fn).call(this, ok, "click", () => __privateMethod(this, _FxEditor_instances, submitDialog_fn).call(this));
+  const applySource = this.root.querySelector(".source-apply");
+  if (applySource) __privateMethod(this, _FxEditor_instances, on_fn).call(this, applySource, "click", () => __privateMethod(this, _FxEditor_instances, applySource_fn).call(this));
+  const cancelSource = this.root.querySelector(".source-cancel");
+  if (cancelSource) __privateMethod(this, _FxEditor_instances, on_fn).call(this, cancelSource, "click", () => __privateMethod(this, _FxEditor_instances, cancelSource_fn).call(this));
+};
+syncChrome_fn = function() {
+  const editor = this.editor;
+  if (!editor) return;
+  const locked = this.disabled || this.readonly;
+  editor.setAttribute("contenteditable", locked ? "false" : "true");
+  editor.setAttribute("aria-readonly", String(this.readonly));
+  editor.setAttribute("aria-disabled", String(this.disabled));
+  if (this.placeholder) editor.setAttribute("data-placeholder", this.placeholder);
+  else editor.removeAttribute("data-placeholder");
+  const toolbar = this.toolbarEl;
+  toolbar?.toggleAttribute("hidden", this.toolbar === "none" || this.readonly);
+  for (const control of Array.from(this.root.querySelectorAll(
+    ".tb-btn, .tb-select, .tb-color input"
+  ))) {
+    const isSourceToggle = control.closest('[data-action="source"]') !== null;
+    const isFullscreenToggle = control.closest('[data-action="fullscreen"]') !== null;
+    control.disabled = this.readonly || this.disabled || __privateGet(this, _sourceMode) && !isSourceToggle && !isFullscreenToggle;
+  }
+  __privateMethod(this, _FxEditor_instances, applyCssVars_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateEmpty_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateCount_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, validate_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateSourceUi_fn).call(this);
+  const fullscreenButton = this.root.querySelector('[data-action="fullscreen"]');
+  fullscreenButton?.classList.toggle("active", this.fullscreen);
+  fullscreenButton?.setAttribute("aria-pressed", String(this.fullscreen));
+  if (locked || __privateGet(this, _sourceMode)) __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+};
+applyCssVars_fn = function() {
+  const min = this.getAttr("min-height");
+  const max = this.getAttr("max-height");
+  if (min) this.style.setProperty("--fx-editor-min-height", min);
+  else this.style.removeProperty("--fx-editor-min-height");
+  if (max) this.style.setProperty("--fx-editor-max-height", max);
+  else this.style.removeProperty("--fx-editor-max-height");
+};
+updateEmpty_fn = function() {
+  const editor = this.editor;
+  if (!editor) return;
+  const empty = !editor.textContent?.trim() && !editor.querySelector("img,video,iframe,table,hr");
+  editor.classList.toggle("is-empty", empty);
+};
+updateCount_fn = function() {
+  const count = this.root.querySelector(".count");
+  if (!count) return;
+  const statusbar = this.root.querySelector(".statusbar");
+  const hasFooter = this.querySelector('[slot="footer"]') !== null;
+  if (statusbar) statusbar.hidden = !__privateGet(this, _sourceMode) && !this.hasAttr("show-count") && !hasFooter;
+  if (!this.hasAttr("show-count")) {
+    count.textContent = "";
+    return;
+  }
+  const text = this.text;
+  const words = text ? text.split(/\s+/).filter(Boolean).length : 0;
+  count.textContent = `${words} palavra${words === 1 ? "" : "s"} · ${text.length} caractere${text.length === 1 ? "" : "s"}`;
+};
+fits_fn = function(extra) {
+  const max = this.maxlength;
+  if (!max) return true;
+  const editor = this.editor;
+  const range = editor ? getRange(editor, __privateGet(this, _lastRange)) : null;
+  const selected = range && !range.collapsed ? range.toString().length : 0;
+  return this.text.length - selected + extra <= max;
+};
+limitError_fn = function() {
+  const now = Date.now();
+  if (now - __privateGet(this, _lastLimitError) < 1200) return;
+  __privateSet(this, _lastLimitError, now);
+  __privateMethod(this, _FxEditor_instances, error_fn).call(this, `Limite de ${this.maxlength.toLocaleString("pt-BR")} caracteres atingido.`);
+};
+validate_fn = function() {
+  if (!this.internals || typeof this.internals.setValidity !== "function") return;
+  try {
+    if (this.required && !this.text) {
+      this.internals.setValidity(
+        { valueMissing: true },
+        "Preencha este campo.",
+        this.editor ?? void 0
+      );
+    } else {
+      this.internals.setValidity({});
+    }
+  } catch {
+  }
+};
+/** Sanitiza + normaliza em uma única parseada do HTML. */
+cleanHtml_fn = function(html, forEditor = false) {
+  const body = sanitizeBody(html);
+  if (!body) return forEditor ? "<p><br></p>" : "";
+  return normalizeElement(body, { forEditor });
+};
+serialize_fn = function() {
+  if (__privateGet(this, _sourceMode) && this.source) {
+    return __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, this.source.value);
+  }
+  const editor = this.editor;
+  if (!editor) return "";
+  if (!editor.textContent?.trim() && !editor.querySelector("img,video,iframe,table,hr")) return "";
+  let clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, editor.innerHTML);
+  if (this.sanitizeHtml) {
+    clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, this.sanitizeHtml(clean));
+  }
+  return clean;
+};
+applyValue_fn = function(html) {
+  const editor = this.editor;
+  if (!editor) return;
+  __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+  const normalized = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, html, true);
+  if (editor.innerHTML !== normalized) editor.innerHTML = normalized;
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, decorateMediaFigures_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateEmpty_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateCount_fn).call(this);
+};
+scheduleEmit_fn = function() {
+  cancelAnimationFrame(__privateGet(this, _rafId));
+  if (__privateGet(this, _emitTimer)) {
+    clearTimeout(__privateGet(this, _emitTimer));
+    __privateSet(this, _emitTimer, null);
+  }
+  const size = this.editor?.textContent?.length ?? 0;
+  if (size < LARGE_DOC_CHARS) {
+    __privateSet(this, _rafId, requestAnimationFrame(() => __privateMethod(this, _FxEditor_instances, emitNow_fn).call(this)));
+    return;
+  }
+  __privateSet(this, _emitTimer, setTimeout(() => {
+    __privateSet(this, _emitTimer, null);
+    __privateMethod(this, _FxEditor_instances, emitNow_fn).call(this);
+  }, EMIT_DEBOUNCE_MS));
+};
+emitNow_fn = function() {
+  cancelAnimationFrame(__privateGet(this, _rafId));
+  if (__privateGet(this, _emitTimer)) {
+    clearTimeout(__privateGet(this, _emitTimer));
+    __privateSet(this, _emitTimer, null);
+  }
+  const value = __privateMethod(this, _FxEditor_instances, serialize_fn).call(this);
+  __privateSet(this, _value, value);
+  __privateSet(this, _dirty, false);
+  const detail = { value, html: value, text: this.text };
+  for (const type of ["input", "valueChange"]) {
+    this.dispatchEvent(new CustomEvent(type, { bubbles: true, composed: true, detail }));
+  }
+  __privateMethod(this, _FxEditor_instances, updateCount_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, validate_fn).call(this);
+};
+emitChange_fn = function() {
+  const value = this.value;
+  const detail = { value, html: value, text: this.text };
+  this.dispatchEvent(new CustomEvent("change", { bubbles: true, composed: true, detail }));
+};
+pushHistory_fn = function(html) {
+  if (__privateGet(this, _history)[__privateGet(this, _historyIndex)] === html) return;
+  __privateSet(this, _history, __privateGet(this, _history).slice(0, __privateGet(this, _historyIndex) + 1));
+  __privateGet(this, _history).push(html);
+  if (__privateGet(this, _history).length > HISTORY_LIMIT) __privateGet(this, _history).shift();
+  __privateSet(this, _historyIndex, __privateGet(this, _history).length - 1);
+};
+scheduleSnapshot_fn = function() {
+  if (__privateGet(this, _snapshotTimer)) clearTimeout(__privateGet(this, _snapshotTimer));
+  __privateSet(this, _snapshotTimer, setTimeout(() => {
+    __privateMethod(this, _FxEditor_instances, pushHistory_fn).call(this, __privateGet(this, _dirty) ? __privateMethod(this, _FxEditor_instances, serialize_fn).call(this) : __privateGet(this, _value));
+  }, 600));
+};
+historyUndo_fn = function() {
+  if (__privateGet(this, _historyIndex) <= 0) return;
+  __privateWrapper(this, _historyIndex)._--;
+  __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, __privateGet(this, _history)[__privateGet(this, _historyIndex)]);
+  if (this.editor) placeCaretAtEnd(this.editor);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+historyRedo_fn = function() {
+  if (__privateGet(this, _historyIndex) >= __privateGet(this, _history).length - 1) return;
+  __privateWrapper(this, _historyIndex)._++;
+  __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, __privateGet(this, _history)[__privateGet(this, _historyIndex)]);
+  if (this.editor) placeCaretAtEnd(this.editor);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+bindGlobalSelection_fn = function() {
+  const handler = () => {
+    const editor = this.editor;
+    if (!editor) return;
+    const range = getRange(editor, __privateGet(this, _lastRange));
+    if (!range) return;
+    __privateSet(this, _lastRange, range.cloneRange());
+    cancelAnimationFrame(__privateGet(this, _selectionRaf));
+    __privateSet(this, _selectionRaf, requestAnimationFrame(() => __privateMethod(this, _FxEditor_instances, updateToolbar_fn).call(this)));
+  };
+  document.addEventListener("selectionchange", handler);
+  __privateGet(this, _disposers).push(() => document.removeEventListener("selectionchange", handler));
+};
+restoreSelection_fn = function() {
+  const editor = this.editor;
+  if (!editor) return;
+  if (__privateGet(this, _lastRange)) restoreRange(editor, __privateGet(this, _lastRange));
+  else editor.focus({ preventScroll: true });
+};
+syncBodyOverflow_fn = function() {
+  if (this.fullscreen) {
+    __privateSet(this, _bodyOverflow, document.body.style.overflow);
+    document.body.style.overflow = "hidden";
+  } else {
+    document.body.style.overflow = __privateGet(this, _bodyOverflow);
+  }
+};
+updateSourceUi_fn = function() {
+  const source = this.source;
+  const content = this.editor;
+  const actions = this.root.querySelector(".source-actions");
+  if (actions) actions.toggleAttribute("hidden", !__privateGet(this, _sourceMode));
+  if (source) source.hidden = !__privateGet(this, _sourceMode);
+  if (content) content.hidden = __privateGet(this, _sourceMode);
+  const toggle = this.root.querySelector('[data-action="source"]');
+  toggle?.classList.toggle("active", __privateGet(this, _sourceMode));
+  toggle?.setAttribute("aria-pressed", String(__privateGet(this, _sourceMode)));
+};
+releaseDialog_fn = function(result) {
+  const backdrop = this.root.querySelector(".backdrop");
+  backdrop?.setAttribute("hidden", "");
+  const resolve = __privateGet(this, _dialogResolve);
+  __privateSet(this, _dialogResolve, null);
+  const returnFocus = __privateGet(this, _dialogReturnFocus);
+  __privateSet(this, _dialogReturnFocus, null);
+  resolve?.(result);
+  if (returnFocus && returnFocus.isConnected) returnFocus.focus({ preventScroll: true });
+  else __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+};
+renderToolbar_fn = function() {
+  const toolbar = this.toolbarEl;
+  if (!toolbar) return;
+  const preset = this.toolbar;
+  if (preset === "none") {
+    toolbar.innerHTML = "";
+    toolbar.hidden = true;
+    return;
+  }
+  toolbar.hidden = false;
+  const features = new Set(
+    this.getAttr("features").split(",").map((item) => item.trim()).filter(Boolean)
+  );
+  const has = (feature) => features.size === 0 || features.has(feature);
+  const button = (cmd, icon, label, action = "") => `<button type="button" class="tb-btn" tabindex="-1" ${action ? `data-action="${action}"` : `data-cmd="${cmd}"`} title="${label}" aria-label="${label}" aria-pressed="false">${fenixIconHtml(icon)}</button>`;
+  const select = `<select class="tb-select" data-block aria-label="Formato do bloco">
+      <option value="p">Parágrafo</option>
+      <option value="h1">Título 1</option>
+      <option value="h2">Título 2</option>
+      <option value="h3">Título 3</option>
+      <option value="h4">Título 4</option>
+      <option value="blockquote">Citação</option>
+      <option value="pre">Código</option>
+    </select>`;
+  const history = button("undo", "undo", "Desfazer") + button("redo", "redo", "Refazer");
+  const inline = [
+    button("bold", "format_bold", "Negrito"),
+    button("italic", "format_italic", "Itálico"),
+    button("underline", "format_underlined", "Sublinhado"),
+    button("strikeThrough", "format_strikethrough", "Riscado"),
+    button("code", "code", "Código inline"),
+    button("removeFormat", "format_clear", "Limpar formatação")
+  ].join("");
+  const color = [
+    `<label class="tb-color" title="Cor do texto"><input type="color" data-color="foreColor" value="#111827" aria-label="Cor do texto"></label>`,
+    `<label class="tb-color" title="Realçar texto"><input type="color" data-color="hiliteColor" value="#fef08a" aria-label="Realçar texto"></label>`
+  ].join("");
+  const alignGroup = [
+    button("justifyLeft", "format_align_left", "Alinhar à esquerda"),
+    button("justifyCenter", "format_align_center", "Centralizar"),
+    button("justifyRight", "format_align_right", "Alinhar à direita"),
+    button("justifyFull", "format_align_justify", "Justificar")
+  ].join("");
+  const indentation = [
+    button("outdent", "format_indent_decrease", "Diminuir recuo", "outdent"),
+    button("indent", "format_indent_increase", "Aumentar recuo", "indent")
+  ].join("");
+  const lists = [
+    button("insertUnorderedList", "format_list_bulleted", "Lista com marcadores"),
+    button("insertOrderedList", "format_list_numbered", "Lista numerada")
+  ].join("");
+  const blocks = button("", "format_quote", "Citação", "blockquote") + button("", "code_blocks", "Bloco de código", "codeblock");
+  const insert = [];
+  if (has("link")) {
+    insert.push(button("", "link", "Link (Ctrl+K)", "link"));
+    insert.push(button("", "link_off", "Remover link", "unlink"));
+  }
+  if (preset !== "minimal") {
+    if (has("image")) insert.push(button("", "image", "Imagem", "image"));
+    if (has("video")) insert.push(button("", "videocam", "Vídeo", "video"));
+    if (has("table")) insert.push(button("", "table", "Tabela", "table"));
+    if (has("columns")) insert.push(button("", "view_column", "Colunas", "columns"));
+    insert.push(button("insertHorizontalRule", "horizontal_rule", "Linha horizontal"));
+  }
+  const tools = [];
+  if (preset === "standard" || preset === "full") {
+    if (has("source")) tools.push(button("", "code", "Ver HTML", "source"));
+    if (has("fullscreen")) tools.push(button("", "fullscreen", "Tela cheia", "fullscreen"));
+  }
+  const groups = [history, select + inline];
+  if (preset !== "minimal") groups.push(lists);
+  if (preset !== "minimal" && preset !== "basic") {
+    groups.push(color, alignGroup, indentation, blocks);
+  }
+  if (insert.length) groups.push(insert.join(""));
+  if (tools.length) groups.push(tools.join(""));
+  toolbar.innerHTML = groups.map((group) => `<div class="tb-group">${group}</div>`).join("") + `<div class="panel" data-panel hidden></div>`;
+  toolbar.querySelector(".tb-btn")?.setAttribute("tabindex", "0");
+};
+updateToolbar_fn = function() {
+  const editor = this.editor;
+  if (!editor) return;
+  const range = getRange(editor, __privateGet(this, _lastRange));
+  if (!range) return;
+  const setActive = (cmd, active) => {
+    const button = this.root.querySelector(`[data-cmd="${cmd}"]`);
+    if (!button) return;
+    button.classList.toggle("active", active);
+    button.setAttribute("aria-pressed", String(active));
+  };
+  const ancestor = (selector) => {
+    const node = range.startContainer;
+    const el = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+    const match = el?.closest(selector);
+    return Boolean(match && editor.contains(match));
+  };
+  setActive("bold", ancestor("strong,b"));
+  setActive("italic", ancestor("em,i"));
+  setActive("underline", ancestor("u"));
+  setActive("strikeThrough", ancestor("s,del,strike"));
+  setActive("code", ancestor("code"));
+  setActive("insertUnorderedList", ancestor("ul"));
+  setActive("insertOrderedList", ancestor("ol"));
+  const block = getBlock(editor, range);
+  const blockTag = block?.tagName.toLowerCase() ?? "p";
+  const blockSelect = this.root.querySelector("[data-block]");
+  if (blockSelect) {
+    const value = Array.from(blockSelect.options).some((option) => option.value === blockTag) ? blockTag : "p";
+    blockSelect.value = value;
+  }
+  const alignment = block ? block.style.textAlign || "left" : "left";
+  setActive("justifyLeft", alignment === "left" || alignment === "start" || alignment === "");
+  setActive("justifyCenter", alignment === "center");
+  setActive("justifyRight", alignment === "right" || alignment === "end");
+  setActive("justifyFull", alignment === "justify");
+};
+handleToolbarKeydown_fn = function(event) {
+  const active = this.root.activeElement;
+  if (!active || !active.classList.contains("tb-btn")) return;
+  if (!["ArrowRight", "ArrowLeft", "Home", "End"].includes(event.key)) return;
+  const controls = Array.from(
+    this.toolbarEl?.querySelectorAll(
+      ".tb-btn:not(:disabled), .tb-select:not(:disabled), .tb-color input:not(:disabled)"
+    ) ?? []
+  );
+  if (!controls.length) return;
+  event.preventDefault();
+  let index = controls.indexOf(active);
+  if (event.key === "Home") index = 0;
+  else if (event.key === "End") index = controls.length - 1;
+  else index = (index + (event.key === "ArrowRight" ? 1 : -1) + controls.length) % controls.length;
+  const next = controls[index];
+  if (!next) return;
+  __privateMethod(this, _FxEditor_instances, moveToolbarTabStop_fn).call(this, next);
+  next.focus();
+};
+moveToolbarTabStop_fn = function(active) {
+  this.toolbarEl?.querySelectorAll(".tb-btn").forEach((button) => {
+    button.setAttribute("tabindex", button === active ? "0" : "-1");
+  });
+};
+trapDialogFocus_fn = function(event) {
+  if (!__privateGet(this, _dialogResolve) || event.key !== "Tab") return;
+  const dialog = this.root.querySelector(".dialog");
+  if (!dialog) return;
+  const focusables = Array.from(
+    dialog.querySelectorAll(
+      'button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], [tabindex]:not([tabindex="-1"])'
+    )
+  );
+  if (!focusables.length) return;
+  const first = focusables[0];
+  const last = focusables[focusables.length - 1];
+  const active = this.root.activeElement;
+  if (event.shiftKey && (active === first || !active || !dialog.contains(active))) {
+    event.preventDefault();
+    last.focus();
+  } else if (!event.shiftKey && (active === last || !active || !dialog.contains(active))) {
+    event.preventDefault();
+    first.focus();
+  }
+};
+execCommand_fn = function(cmd) {
+  const editor = this.editor;
+  if (!editor) return;
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  switch (cmd) {
+    case "undo":
+      if (!nativeExec("undo")) __privateMethod(this, _FxEditor_instances, historyUndo_fn).call(this);
+      break;
+    case "redo":
+      if (!nativeExec("redo")) __privateMethod(this, _FxEditor_instances, historyRedo_fn).call(this);
+      break;
+    case "bold":
+      toggleInline(editor, "strong");
+      break;
+    case "italic":
+      toggleInline(editor, "em");
+      break;
+    case "underline":
+      toggleInline(editor, "u");
+      break;
+    case "strikeThrough":
+      toggleInline(editor, "s");
+      break;
+    case "code":
+      toggleInline(editor, "code");
+      break;
+    case "justifyLeft":
+      align(editor, "left");
+      break;
+    case "justifyCenter":
+      align(editor, "center");
+      break;
+    case "justifyRight":
+      align(editor, "right");
+      break;
+    case "justifyFull":
+      align(editor, "justify");
+      break;
+    case "insertUnorderedList":
+      toggleList(editor, false);
+      break;
+    case "insertOrderedList":
+      toggleList(editor, true);
+      break;
+    case "removeFormat":
+      removeFormat(editor);
+      break;
+    case "insertHorizontalRule":
+      insertHtml(editor, "<hr><p><br></p>");
+      break;
+    case "foreColor":
+    case "hiliteColor":
+      nativeExec("styleWithCSS", "true");
+      nativeExec(cmd, this.root.querySelector(`[data-color="${cmd}"]`)?.value);
+      break;
+    default:
+      nativeExec(cmd);
+  }
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+afterCommand_fn = function() {
+  __privateSet(this, _dirty, true);
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, decorateMediaFigures_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateEmpty_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, scheduleEmit_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, scheduleSnapshot_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, updateToolbar_fn).call(this);
+};
+action_fn = function(action) {
+  const editor = this.editor;
+  if (!editor) return;
+  switch (action) {
+    case "link":
+      void __privateMethod(this, _FxEditor_instances, openLinkDialog_fn).call(this);
+      break;
+    case "image":
+      void __privateMethod(this, _FxEditor_instances, openImageDialog_fn).call(this);
+      break;
+    case "video":
+      void __privateMethod(this, _FxEditor_instances, openVideoDialog_fn).call(this);
+      break;
+    case "table":
+      __privateMethod(this, _FxEditor_instances, showTablePanel_fn).call(this);
+      break;
+    case "columns":
+      __privateMethod(this, _FxEditor_instances, showColumnsPanel_fn).call(this);
+      break;
+    case "source":
+      __privateMethod(this, _FxEditor_instances, toggleSource_fn).call(this);
+      break;
+    case "fullscreen":
+      this.fullscreen = !this.fullscreen;
+      break;
+    case "blockquote":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      formatBlock(editor, "blockquote");
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+    case "codeblock":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      formatBlock(editor, "pre");
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+    case "indent":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      indent(editor, 24);
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+    case "outdent":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      indent(editor, -24);
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+    case "clear":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      removeFormat(editor);
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+    case "unlink":
+      __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+      unlink(editor);
+      __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+      break;
+  }
+};
+handleKeydown_fn = function(event) {
+  if (event.isComposing) return;
+  const active = this.root.activeElement;
+  const overlay = this.root.querySelector(".media-overlay");
+  if (__privateGet(this, _mediaFigure) && (event.key === "Delete" || event.key === "Backspace") && (active === __privateGet(this, _mediaFigure) || __privateGet(this, _mediaFigure).contains(active) || Boolean(overlay && active && overlay.contains(active)))) {
+    event.preventDefault();
+    __privateMethod(this, _FxEditor_instances, deleteMediaFigure_fn).call(this);
+    return;
+  }
+  const mod = event.ctrlKey || event.metaKey;
+  const key = event.key.toLowerCase();
+  if (mod && !event.altKey) {
+    if (key === "b") {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, "bold");
+      return;
+    }
+    if (key === "i") {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, "italic");
+      return;
+    }
+    if (key === "u") {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, "underline");
+      return;
+    }
+    if (key === "k") {
+      event.preventDefault();
+      void __privateMethod(this, _FxEditor_instances, openLinkDialog_fn).call(this);
+      return;
+    }
+    if (key === "z" && !event.shiftKey) {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, "undo");
+      return;
+    }
+    if (key === "y" || key === "z" && event.shiftKey) {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, execCommand_fn).call(this, "redo");
+      return;
+    }
+  }
+  if (event.key === "Escape") {
+    if (__privateGet(this, _dialogResolve)) __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, null);
+    else if (__privateGet(this, _sourceMode)) __privateMethod(this, _FxEditor_instances, cancelSource_fn).call(this);
+    else if (this.fullscreen) this.fullscreen = false;
+    else if (__privateGet(this, _linkAnchor)) __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+    else if (__privateGet(this, _mediaFigure)) __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+    else __privateMethod(this, _FxEditor_instances, hidePanel_fn).call(this);
+    return;
+  }
+  if (event.key === "Tab" && __privateMethod(this, _FxEditor_instances, tabInTable_fn).call(this, event.shiftKey)) {
+    event.preventDefault();
+  }
+};
+tabInTable_fn = function(backwards) {
+  const editor = this.editor;
+  if (!editor) return false;
+  const range = getRange(editor, __privateGet(this, _lastRange));
+  if (!range) return false;
+  const cell = closestInEditor(editor, range.startContainer, "td,th");
+  const table = cell?.closest("table");
+  if (!cell || !table) return false;
+  const cells = Array.from(table.querySelectorAll("td,th"));
+  let index = cells.indexOf(cell);
+  if (index < 0) return false;
+  if (backwards) {
+    index = Math.max(0, index - 1);
+  } else {
+    index++;
+    if (index >= cells.length) {
+      const row = cell.parentElement;
+      if (!row) return false;
+      const clone = row.cloneNode(true);
+      for (const cloned of Array.from(clone.querySelectorAll("td,th"))) {
+        cloned.innerHTML = "<p><br></p>";
+      }
+      row.after(clone);
+      cells.push(...Array.from(clone.querySelectorAll("td,th")));
+      index = cells.indexOf(clone.querySelector("td,th"));
+    }
+  }
+  const target = cells[index];
+  if (!target) return false;
+  const next = document.createRange();
+  next.selectNodeContents(target);
+  next.collapse(true);
+  const selection = document.getSelection();
+  selection?.removeAllRanges();
+  selection?.addRange(next);
+  return true;
+};
+handleBeforeInput_fn = function(event) {
+  if (this.disabled || this.readonly || !this.maxlength) return;
+  const type = event.inputType;
+  if (type === "insertFromPaste" || type === "insertFromDrop" || type.startsWith("history") || type.startsWith("format")) {
+    return;
+  }
+  const extra = event.data?.length ?? (type === "insertParagraph" || type === "insertLineBreak" ? 1 : 0);
+  if (!extra) return;
+  if (!__privateMethod(this, _FxEditor_instances, fits_fn).call(this, extra)) {
+    event.preventDefault();
+    __privateMethod(this, _FxEditor_instances, limitError_fn).call(this);
+  }
+};
+handlePaste_fn = function(event) {
+  const clipboard = event.clipboardData;
+  if (!clipboard) return;
+  const file = Array.from(clipboard.files ?? []).find((item) => item.type.startsWith("image/"));
+  if (file) {
+    event.preventDefault();
+    void __privateMethod(this, _FxEditor_instances, handleImageFile_fn).call(this, file);
+    return;
+  }
+  const html = clipboard.getData("text/html");
+  const text = clipboard.getData("text/plain");
+  if (html.length > MAX_PASTE_BYTES || text.length > MAX_PASTE_BYTES) return;
+  event.preventDefault();
+  if (!__privateMethod(this, _FxEditor_instances, fits_fn).call(this, text.length)) {
+    __privateMethod(this, _FxEditor_instances, limitError_fn).call(this);
+    return;
+  }
+  if (this.pasteMode === "plain" || !html) {
+    __privateMethod(this, _FxEditor_instances, insertPlainText_fn).call(this, text);
+    return;
+  }
+  const clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, html);
+  if (!clean) {
+    __privateMethod(this, _FxEditor_instances, insertPlainText_fn).call(this, text);
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  insertHtml(this.editor, clean);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+handleDrop_fn = function(event) {
+  const transfer = event.dataTransfer;
+  if (!transfer) return;
+  event.preventDefault();
+  const file = Array.from(transfer.files ?? []).find((item) => item.type.startsWith("image/"));
+  if (file) {
+    void __privateMethod(this, _FxEditor_instances, handleImageFile_fn).call(this, file);
+    return;
+  }
+  const html = transfer.getData("text/html");
+  const text = transfer.getData("text/plain");
+  if (!__privateMethod(this, _FxEditor_instances, fits_fn).call(this, text.length)) {
+    __privateMethod(this, _FxEditor_instances, limitError_fn).call(this);
+    return;
+  }
+  if (html) {
+    insertHtml(this.editor, __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, html));
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  } else if (text) {
+    __privateMethod(this, _FxEditor_instances, insertPlainText_fn).call(this, text);
+  }
+};
+insertPlainText_fn = function(text) {
+  const paragraphs = text.replace(/\r\n/g, "\n").split(/\n{2,}/).map((block) => `<p>${escapeText(block).replace(/\n/g, "<br>")}</p>`).join("");
+  insertHtml(this.editor, paragraphs || "<p><br></p>");
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+toggleSource_fn = function() {
+  if (__privateGet(this, _sourceMode)) {
+    __privateMethod(this, _FxEditor_instances, applySource_fn).call(this);
+    return;
+  }
+  const source = this.source;
+  if (!source) return;
+  source.value = __privateMethod(this, _FxEditor_instances, serialize_fn).call(this);
+  __privateSet(this, _sourceMode, true);
+  __privateMethod(this, _FxEditor_instances, syncChrome_fn).call(this);
+  source.focus();
+};
+applySource_fn = function() {
+  const source = this.source;
+  if (!source) return;
+  const clean = __privateMethod(this, _FxEditor_instances, cleanHtml_fn).call(this, source.value);
+  __privateSet(this, _sourceMode, false);
+  __privateSet(this, _value, clean);
+  __privateSet(this, _dirty, false);
+  __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, clean);
+  __privateMethod(this, _FxEditor_instances, syncChrome_fn).call(this);
+  this.updateFormValue();
+  __privateMethod(this, _FxEditor_instances, emitChange_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+cancelSource_fn = function() {
+  __privateSet(this, _sourceMode, false);
+  __privateMethod(this, _FxEditor_instances, applyValue_fn).call(this, __privateGet(this, _value));
+  __privateMethod(this, _FxEditor_instances, syncChrome_fn).call(this);
+};
+openDialog_fn = function(title, fields) {
+  const backdrop = this.root.querySelector(".backdrop");
+  const titleEl = this.root.querySelector(".dialog h3");
+  const body = this.root.querySelector(".dialog-body");
+  if (!backdrop || !titleEl || !body) return Promise.resolve(null);
+  titleEl.textContent = title;
+  body.innerHTML = fields.map((field) => __privateMethod(this, _FxEditor_instances, fieldHtml_fn).call(this, field)).join("");
+  __privateSet(this, _dialogReturnFocus, this.root.activeElement ?? this.editor);
+  backdrop.removeAttribute("hidden");
+  const first = body.querySelector("input,select");
+  first?.focus();
+  return new Promise((resolve) => {
+    __privateSet(this, _dialogResolve, resolve);
+  });
+};
+fieldHtml_fn = function(field) {
+  const label = esc(field.label);
+  if (field.type === "select") {
+    const options = (field.options ?? []).map((option) => `<option value="${esc(option.value)}" ${option.value === field.value ? "selected" : ""}>${esc(option.label)}</option>`).join("");
+    return `<label class="field"><span>${label}</span><select data-field="${esc(field.name)}">${options}</select></label>`;
+  }
+  const type = field.type === "url" ? "url" : field.type === "number" ? "number" : "text";
+  return `<label class="field"><span>${label}</span><input data-field="${esc(field.name)}" type="${type}" value="${esc(field.value ?? "")}" placeholder="${esc(field.placeholder ?? "")}"></label>`;
+};
+submitDialog_fn = function() {
+  const body = this.root.querySelector(".dialog-body");
+  if (!body) return;
+  const result = {};
+  for (const field of Array.from(body.querySelectorAll("[data-field]"))) {
+    result[field.dataset.field ?? ""] = field.value.trim();
+  }
+  __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, result);
+};
+openLinkDialog_fn = async function(existing) {
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  const editor = this.editor;
+  if (!editor) return;
+  if (existing) __privateMethod(this, _FxEditor_instances, selectAnchor_fn).call(this, existing);
+  let range = getRange(editor, __privateGet(this, _lastRange));
+  if (!range) {
+    placeCaretAtEnd(editor);
+    range = getRange(editor);
+    __privateSet(this, _lastRange, range?.cloneRange() ?? null);
+  }
+  const anchor = existing ?? closestInEditor(editor, range?.startContainer ?? null, "a");
+  const selected = range && !range.collapsed ? range.toString() : anchor?.textContent ?? "";
+  const result = await __privateMethod(this, _FxEditor_instances, openDialog_fn).call(this, "Link", [
+    { name: "url", label: "URL", type: "url", value: anchor?.getAttribute("href") ?? "", placeholder: "https://..." },
+    { name: "text", label: "Texto (quando não há seleção)", value: selected, placeholder: "Texto do link" },
+    {
+      name: "target",
+      label: "Abrir em",
+      type: "select",
+      value: anchor?.getAttribute("target") ?? "_blank",
+      options: [
+        { value: "_blank", label: "Nova aba" },
+        { value: "_self", label: "Mesma aba" }
+      ]
+    }
+  ]);
+  if (!result) return;
+  const href = sanitizeLinkUrl(result.url ?? "");
+  if (!href) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "URL de link inválida.");
+    return;
+  }
+  const target = result.target === "_self" ? "_self" : "_blank";
+  const label = (result.text ?? "").trim() || (anchor ? void 0 : selected || href);
+  if (anchor) {
+    anchor.setAttribute("href", href);
+    anchor.setAttribute("target", target);
+    anchor.setAttribute("rel", "noopener noreferrer");
+    if (label) anchor.textContent = label;
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  applyLink(editor, href, label ?? (selected || href), target);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+openImageDialog_fn = async function(existing) {
+  __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+  const figure = existing?.closest("figure");
+  const caption = figure?.querySelector("figcaption")?.textContent ?? "";
+  const alignValue = figure?.getAttribute("data-align") ?? "center";
+  const widthValue = figure?.style.width?.replace("%", "") || "100";
+  const dialog = __privateMethod(this, _FxEditor_instances, openDialog_fn).call(this, existing ? "Editar imagem" : "Inserir imagem", [
+    { name: "src", label: "URL da imagem", type: "url", value: existing?.getAttribute("src") ?? "", placeholder: "https://..." },
+    { name: "alt", label: "Texto alternativo", value: existing?.getAttribute("alt") ?? "" },
+    { name: "caption", label: "Legenda", value: caption },
+    {
+      name: "width",
+      label: "Largura",
+      type: "select",
+      value: widthValue,
+      options: [
+        { value: "25", label: "25%" },
+        { value: "50", label: "50%" },
+        { value: "75", label: "75%" },
+        { value: "100", label: "100%" }
+      ]
+    },
+    {
+      name: "align",
+      label: "Alinhamento",
+      type: "select",
+      value: alignValue,
+      options: [
+        { value: "left", label: "Esquerda" },
+        { value: "center", label: "Centro" },
+        { value: "right", label: "Direita" }
+      ]
+    }
+  ]);
+  const body = this.root.querySelector(".dialog-body");
+  if (body) {
+    const upload = document.createElement("button");
+    upload.type = "button";
+    upload.className = "btn";
+    upload.textContent = "Escolher arquivo…";
+    upload.addEventListener("click", () => {
+      __privateMethod(this, _FxEditor_instances, releaseDialog_fn).call(this, null);
+      __privateGet(this, _imagePicker)?.click();
+    });
+    body.appendChild(upload);
+  }
+  const result = await dialog;
+  if (!result) return;
+  const src = sanitizeMediaUrl(result.src ?? "", "img");
+  if (!src) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "URL de imagem inválida.");
+    return;
+  }
+  if (existing && figure) {
+    existing.setAttribute("src", src);
+    existing.setAttribute("alt", result.alt ?? "");
+    figure.setAttribute("data-align", result.align || "center");
+    figure.style.width = `${result.width || 100}%`;
+    const cap = figure.querySelector("figcaption");
+    if (result.caption) {
+      if (cap) cap.textContent = result.caption;
+      else figure.insertAdjacentHTML("beforeend", `<figcaption>${escapeText(result.caption)}</figcaption>`);
+    } else {
+      cap?.remove();
+    }
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, insertImage_fn).call(this, src, result.alt ?? "", result.caption ?? "", result.width || "100", result.align || "center");
+};
+toEmbedUrl_fn = function(value) {
+  try {
+    const url = new URL(value);
+    const host = url.hostname.replace(/^www\./, "");
+    if (host === "youtu.be") {
+      return `https://www.youtube-nocookie.com/embed/${url.pathname.slice(1)}`;
+    }
+    if (host === "youtube.com" || host === "m.youtube.com") {
+      const id = url.searchParams.get("v");
+      if (id) return `https://www.youtube-nocookie.com/embed/${id}`;
+      if (url.pathname.startsWith("/shorts/")) {
+        return `https://www.youtube-nocookie.com/embed/${url.pathname.split("/")[2] ?? ""}`;
+      }
+    }
+    if (host === "vimeo.com") {
+      const id = url.pathname.split("/").filter(Boolean)[0];
+      if (id) return `https://player.vimeo.com/video/${id}`;
+    }
+    return value;
+  } catch {
+    return value;
+  }
+};
+openVideoDialog_fn = async function() {
+  const result = await __privateMethod(this, _FxEditor_instances, openDialog_fn).call(this, "Inserir vídeo", [
+    { name: "src", label: "URL do vídeo ou embed", type: "url", placeholder: "https://.../video.mp4 ou YouTube/Vimeo" },
+    { name: "caption", label: "Legenda", value: "" },
+    {
+      name: "width",
+      label: "Largura",
+      type: "select",
+      value: "100",
+      options: [
+        { value: "50", label: "50%" },
+        { value: "75", label: "75%" },
+        { value: "100", label: "100%" }
+      ]
+    },
+    {
+      name: "align",
+      label: "Alinhamento",
+      type: "select",
+      value: "center",
+      options: [
+        { value: "left", label: "Esquerda" },
+        { value: "center", label: "Centro" },
+        { value: "right", label: "Direita" }
+      ]
+    }
+  ]);
+  if (!result) return;
+  const src = result.src ?? "";
+  const embed = sanitizeEmbedUrl(__privateMethod(this, _FxEditor_instances, toEmbedUrl_fn).call(this, src));
+  if (embed) {
+    __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, insertEmbed_fn).call(this, embed, result.caption ?? "", result.width || "100", result.align || "center");
+    return;
+  }
+  const media = sanitizeMediaUrl(src, "video");
+  if (!media) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "URL de vídeo inválida.");
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, insertVideo_fn).call(this, media, result.caption ?? "", result.width || "100", result.align || "center");
+};
+decorateMediaFigures_fn = function() {
+  const editor = this.editor;
+  if (!editor || __privateGet(this, _sourceMode)) return;
+  for (const figure of Array.from(
+    editor.querySelectorAll("figure.fx-image, figure.fx-video, figure.fx-embed")
+  )) {
+    if (figure.querySelector(":scope > .fx-media-quick")) {
+      __privateMethod(this, _FxEditor_instances, syncQuickActions_fn).call(this, figure);
+      continue;
+    }
+    for (const kind of ["left", "center", "right", "delete"]) {
+      const label = kind === "delete" ? "Excluir mídia" : kind === "left" ? "Alinhar à esquerda" : kind === "center" ? "Centralizar" : "Alinhar à direita";
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = `fx-media-quick quick-${kind}`;
+      button.title = label;
+      button.setAttribute("aria-label", label);
+      if (kind === "delete") button.dataset.mediaDelete = "";
+      else button.dataset.mediaAlign = kind;
+      button.innerHTML = QUICK_SVG[kind];
+      button.addEventListener("click", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        if (kind === "delete") {
+          figure.remove();
+          __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+          __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+        } else {
+          figure.setAttribute("data-align", kind);
+          __privateMethod(this, _FxEditor_instances, syncQuickActions_fn).call(this, figure);
+          __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+        }
+      });
+      figure.appendChild(button);
+    }
+    __privateMethod(this, _FxEditor_instances, syncQuickActions_fn).call(this, figure);
+  }
+};
+syncQuickActions_fn = function(figure) {
+  const align2 = figure.getAttribute("data-align") || "center";
+  for (const button of Array.from(
+    figure.querySelectorAll(":scope > .fx-media-quick[data-media-align]")
+  )) {
+    button.classList.toggle("active", button.dataset.mediaAlign === align2);
+  }
+};
+selectAnchor_fn = function(anchor) {
+  const editor = this.editor;
+  if (!editor) return;
+  editor.focus({ preventScroll: true });
+  const range = document.createRange();
+  range.selectNodeContents(anchor);
+  const selection = document.getSelection();
+  if (!selection) return;
+  selection.removeAllRanges();
+  selection.addRange(range);
+  __privateSet(this, _lastRange, range.cloneRange());
+};
+handleLinkOverlayClick_fn = function(event) {
+  const action = event.target.closest("[data-link-action]");
+  const anchor = __privateGet(this, _linkAnchor);
+  if (!action || !anchor) return;
+  event.preventDefault();
+  event.stopPropagation();
+  const kind = action.dataset.linkAction;
+  if (kind === "open") __privateMethod(this, _FxEditor_instances, openLink_fn).call(this, anchor);
+  else if (kind === "edit") void __privateMethod(this, _FxEditor_instances, openLinkDialog_fn).call(this, anchor);
+  else if (kind === "remove") __privateMethod(this, _FxEditor_instances, removeLink_fn).call(this, anchor);
+};
+openLink_fn = function(anchor) {
+  const href = anchor.getAttribute("href") ?? "";
+  if (!href) return;
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  const target = anchor.getAttribute("target") === "_self" ? "_self" : "_blank";
+  window.open(href, target, target === "_blank" ? "noopener,noreferrer" : void 0);
+};
+removeLink_fn = function(anchor) {
+  const parent = anchor.parentNode;
+  if (!parent) return;
+  while (anchor.firstChild) parent.insertBefore(anchor.firstChild, anchor);
+  anchor.remove();
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  this.editor?.focus({ preventScroll: true });
+};
+showLinkOverlay_fn = function(anchor) {
+  __privateSet(this, _linkAnchor, anchor);
+  const overlay = this.root.querySelector(".link-overlay");
+  if (!overlay) return;
+  const target = anchor.getAttribute("target") === "_self" ? "mesma janela" : "nova aba";
+  const open = overlay.querySelector('[data-link-action="open"]');
+  if (open) open.title = `Abrir na ${target}`;
+  overlay.hidden = false;
+  __privateMethod(this, _FxEditor_instances, positionLinkOverlay_fn).call(this);
+};
+hideLinkOverlay_fn = function() {
+  __privateSet(this, _linkAnchor, null);
+  const overlay = this.root.querySelector(".link-overlay");
+  if (overlay) overlay.hidden = true;
+};
+positionLinkOverlay_fn = function() {
+  const overlay = this.root.querySelector(".link-overlay");
+  const anchor = __privateGet(this, _linkAnchor);
+  const editor = this.editor;
+  if (!overlay) return;
+  if (!anchor || !editor || __privateGet(this, _sourceMode) || !anchor.isConnected || !editor.contains(anchor)) {
+    overlay.hidden = true;
+    return;
+  }
+  const body = overlay.parentElement;
+  if (!body) return;
+  const bodyRect = body.getBoundingClientRect();
+  const rect = anchor.getBoundingClientRect();
+  if (!rect.width || !rect.height || rect.bottom < bodyRect.top || rect.top > bodyRect.bottom) {
+    overlay.hidden = true;
+    return;
+  }
+  overlay.hidden = false;
+  const width = overlay.offsetWidth || 180;
+  const height = overlay.offsetHeight || 30;
+  const left = Math.max(4, Math.min(rect.left - bodyRect.left, bodyRect.width - width - 4));
+  let top = rect.bottom - bodyRect.top + 6;
+  if (top + height > bodyRect.height) top = rect.top - bodyRect.top - height - 6;
+  overlay.style.left = `${left}px`;
+  overlay.style.top = `${Math.max(4, top)}px`;
+};
+handleEditorClick_fn = function(event) {
+  const target = event.target;
+  const anchor = target.closest("a[href]");
+  if (anchor && this.editor?.contains(anchor)) {
+    __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, showLinkOverlay_fn).call(this, anchor);
+    if (event.ctrlKey || event.metaKey) {
+      event.preventDefault();
+      __privateMethod(this, _FxEditor_instances, openLink_fn).call(this, anchor);
+    }
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, hideLinkOverlay_fn).call(this);
+  const figure = target.closest("figure.fx-image, figure.fx-video, figure.fx-embed");
+  if (figure) __privateMethod(this, _FxEditor_instances, showMediaOverlay_fn).call(this, figure);
+  else __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+};
+showMediaOverlay_fn = function(figure) {
+  __privateSet(this, _mediaFigure, figure);
+  figure.setAttribute("tabindex", "0");
+  if (figure.classList.contains("fx-image")) figure.focus({ preventScroll: true });
+  const overlay = this.root.querySelector(".media-overlay");
+  if (!overlay) return;
+  overlay.hidden = false;
+  __privateMethod(this, _FxEditor_instances, positionMediaOverlay_fn).call(this);
+};
+hideMediaOverlay_fn = function() {
+  __privateGet(this, _mediaFigure)?.removeAttribute("tabindex");
+  __privateSet(this, _mediaFigure, null);
+  const overlay = this.root.querySelector(".media-overlay");
+  if (!overlay) return;
+  overlay.hidden = true;
+  const size = overlay.querySelector(".media-size");
+  if (size) size.textContent = "";
+};
+deleteMediaFigure_fn = function() {
+  const figure = __privateGet(this, _mediaFigure);
+  if (!figure) return;
+  figure.remove();
+  __privateMethod(this, _FxEditor_instances, hideMediaOverlay_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+  this.editor?.focus({ preventScroll: true });
+};
+positionMediaOverlay_fn = function() {
+  const overlay = this.root.querySelector(".media-overlay");
+  const figure = __privateGet(this, _mediaFigure);
+  const editor = this.editor;
+  if (!overlay) return;
+  if (!figure || !editor || __privateGet(this, _sourceMode) || !figure.isConnected || !editor.contains(figure)) {
+    overlay.hidden = true;
+    return;
+  }
+  const body = overlay.parentElement;
+  if (!body) return;
+  const bodyRect = body.getBoundingClientRect();
+  const rect = figure.getBoundingClientRect();
+  if (!rect.width || !rect.height || rect.bottom < bodyRect.top || rect.top > bodyRect.bottom) {
+    overlay.hidden = true;
+    return;
+  }
+  overlay.hidden = false;
+  overlay.style.left = `${rect.left - bodyRect.left}px`;
+  overlay.style.top = `${rect.top - bodyRect.top}px`;
+  overlay.style.width = `${rect.width}px`;
+  overlay.style.height = `${rect.height}px`;
+  const size = overlay.querySelector(".media-size");
+  if (size) size.textContent = `${Math.round(rect.width)} × ${Math.round(rect.height)}`;
+};
+startResize_fn = function(event) {
+  const handle = event.target.closest("[data-handle]");
+  const figure = __privateGet(this, _mediaFigure);
+  const editor = this.editor;
+  if (!handle || !figure || !editor) return;
+  event.preventDefault();
+  event.stopPropagation();
+  __privateMethod(this, _FxEditor_instances, endResize_fn).call(this);
+  const parent = figure.parentElement;
+  if (!parent) return;
+  const parentWidth = parent.getBoundingClientRect().width || editor.clientWidth;
+  if (!parentWidth) return;
+  const rect = figure.getBoundingClientRect();
+  const startWidth = rect.width ? rect.width / parentWidth * 100 : Number.parseFloat(figure.style.width) || 100;
+  const startX = event.clientX;
+  const direction = handle.dataset.handle?.includes("w") ? -1 : 1;
+  const move = (moveEvent) => {
+    const deltaPct = (moveEvent.clientX - startX) * direction * 100 / parentWidth;
+    const width = Math.min(100, Math.max(15, startWidth + deltaPct));
+    figure.style.width = `${width.toFixed(1).replace(/\.0$/, "")}%`;
+    __privateMethod(this, _FxEditor_instances, positionMediaOverlay_fn).call(this);
+  };
+  const up = () => {
+    __privateMethod(this, _FxEditor_instances, endResize_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    __privateMethod(this, _FxEditor_instances, positionMediaOverlay_fn).call(this);
+  };
+  window.addEventListener("pointermove", move);
+  window.addEventListener("pointerup", up, { once: true });
+  window.addEventListener("pointercancel", up, { once: true });
+  __privateSet(this, _resizeDispose, () => {
+    window.removeEventListener("pointermove", move);
+    window.removeEventListener("pointerup", up);
+    window.removeEventListener("pointercancel", up);
+  });
+};
+endResize_fn = function() {
+  var _a;
+  (_a = __privateGet(this, _resizeDispose)) == null ? void 0 : _a.call(this);
+  __privateSet(this, _resizeDispose, null);
+};
+handleDoubleClick_fn = function(event) {
+  const target = event.target;
+  const image = target.closest("img");
+  if (image) {
+    event.preventDefault();
+    void __privateMethod(this, _FxEditor_instances, openImageDialog_fn).call(this, image);
+  }
+};
+insertImage_fn = function(src, alt, caption, width, align2) {
+  const html = `<figure class="fx-image" contenteditable="false" data-align="${escapeAttr(align2)}" style="width:${escapeAttr(width)}%"><img src="${escapeAttr(src)}" alt="${escapeAttr(alt)}" loading="lazy" decoding="async">${caption ? `<figcaption>${escapeText(caption)}</figcaption>` : ""}</figure><p><br></p>`;
+  insertHtml(this.editor, html);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+insertVideo_fn = function(src, caption, width, align2 = "center") {
+  const html = `<figure class="fx-video" contenteditable="false" data-align="${escapeAttr(align2)}" style="width:${escapeAttr(width)}%"><video controls preload="metadata" src="${escapeAttr(src)}" style="width:100%"></video>${caption ? `<figcaption>${escapeText(caption)}</figcaption>` : ""}</figure><p><br></p>`;
+  insertHtml(this.editor, html);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+insertEmbed_fn = function(src, caption, width, align2 = "center") {
+  const html = `<figure class="fx-embed" contenteditable="false" data-align="${escapeAttr(align2)}" style="width:${escapeAttr(width)}%"><iframe src="${escapeAttr(src)}" title="${escapeAttr(caption || "Vídeo")}" loading="lazy" allowfullscreen sandbox="allow-scripts allow-same-origin allow-presentation" referrerpolicy="strict-origin-when-cross-origin" style="width:100%;aspect-ratio:16/9;border:0"></iframe>${caption ? `<figcaption>${escapeText(caption)}</figcaption>` : ""}</figure><p><br></p>`;
+  insertHtml(this.editor, html);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+insertTable_fn = function(rows, cols) {
+  const rowCount = Math.min(20, Math.max(1, rows));
+  const colCount = Math.min(12, Math.max(1, cols));
+  const width = (100 / colCount).toFixed(4).replace(/\.?0+$/, "");
+  const colsHtml = `<colgroup>${Array.from({ length: colCount }, () => `<col style="width:${width}%">`).join("")}</colgroup>`;
+  const head = `<thead><tr>${Array.from({ length: colCount }, () => '<th scope="col"><p><br></p></th>').join("")}</tr></thead>`;
+  const bodyRows = Math.max(0, rowCount - 1);
+  const body = bodyRows ? `<tbody>${Array.from(
+    { length: bodyRows },
+    () => `<tr>${Array.from({ length: colCount }, () => "<td><p><br></p></td>").join("")}</tr>`
+  ).join("")}</tbody>` : "";
+  const html = `<figure class="fx-table"><table>${colsHtml}${head}${body}</table></figure><p><br></p>`;
+  insertHtml(this.editor, html);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+insertColumns_fn = function(cols) {
+  const count = Math.min(4, Math.max(1, cols));
+  const width = (100 / count).toFixed(4).replace(/\.?0+$/, "");
+  const cells = Array.from(
+    { length: count },
+    () => `<td style="width:${width}%;vertical-align:top;padding:8px"><p><br></p></td>`
+  ).join("");
+  const html = `<table class="fx-grid" role="presentation" data-cols="${count}" data-stack="sm" style="width:100%;border-collapse:collapse"><tbody><tr>${cells}</tr></tbody></table><p><br></p>`;
+  insertHtml(this.editor, html);
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+showTablePanel_fn = function() {
+  const panel = this.root.querySelector("[data-panel]");
+  if (!panel) return;
+  const table = __privateMethod(this, _FxEditor_instances, currentTable_fn).call(this);
+  const grid = Array.from({ length: 64 }, (_, index) => {
+    const rows = Math.floor(index / 8) + 1;
+    const cols = index % 8 + 1;
+    return `<button type="button" data-grid="${rows},${cols}" aria-label="${rows} por ${cols}"></button>`;
+  }).join("");
+  panel.innerHTML = `<p class="panel-title">Inserir tabela</p><div class="grid-picker">${grid}</div>` + (table ? `<p class="panel-title" style="margin-top:8px">Tabela atual</p><div class="panel-actions"><button type="button" class="btn" data-table-action="add-row">+ Linha</button><button type="button" class="btn" data-table-action="add-col">+ Coluna</button><button type="button" class="btn" data-table-action="del-row">− Linha</button><button type="button" class="btn" data-table-action="del-col">− Coluna</button><button type="button" class="btn" data-table-action="toggle-header">Cabeçalho</button><button type="button" class="btn" data-table-action="merge-cells">Mesclar</button><button type="button" class="btn" data-table-action="split-cell">Dividir</button><button type="button" class="btn" data-table-action="del-table">Excluir tabela</button></div>` : "");
+  panel.removeAttribute("hidden");
+  panel.querySelectorAll("[data-grid]").forEach((button) => {
+    button.addEventListener("click", () => {
+      const [rows, cols] = (button.dataset.grid ?? "").split(",").map(Number);
+      __privateMethod(this, _FxEditor_instances, hidePanel_fn).call(this);
+      __privateMethod(this, _FxEditor_instances, insertTable_fn).call(this, rows, cols);
+    });
+  });
+  panel.querySelectorAll("[data-table-action]").forEach((button) => {
+    button.addEventListener("click", () => {
+      __privateMethod(this, _FxEditor_instances, tableAction_fn).call(this, button.dataset.tableAction ?? "");
+      __privateMethod(this, _FxEditor_instances, hidePanel_fn).call(this);
+    });
+  });
+};
+showColumnsPanel_fn = function() {
+  const panel = this.root.querySelector("[data-panel]");
+  if (!panel) return;
+  panel.innerHTML = `<p class="panel-title">Inserir colunas</p><div class="panel-actions">` + [1, 2, 3, 4].map((count) => `<button type="button" class="btn" data-columns="${count}">${count}</button>`).join("") + `</div>`;
+  panel.removeAttribute("hidden");
+  panel.querySelectorAll("[data-columns]").forEach((button) => {
+    button.addEventListener("click", () => {
+      __privateMethod(this, _FxEditor_instances, hidePanel_fn).call(this);
+      __privateMethod(this, _FxEditor_instances, insertColumns_fn).call(this, Number(button.dataset.columns ?? 1));
+    });
+  });
+};
+hidePanel_fn = function() {
+  this.root.querySelector("[data-panel]")?.setAttribute("hidden", "");
+};
+currentTable_fn = function() {
+  const editor = this.editor;
+  if (!editor) return null;
+  const range = getRange(editor, __privateGet(this, _lastRange));
+  return closestInEditor(editor, range?.startContainer ?? null, "table");
+};
+tableAction_fn = function(action) {
+  const table = __privateMethod(this, _FxEditor_instances, currentTable_fn).call(this);
+  if (!table) return;
+  const editor = this.editor;
+  const range = editor ? getRange(editor, __privateGet(this, _lastRange)) : null;
+  const cell = editor ? closestInEditor(editor, range?.startContainer ?? null, "td,th") : null;
+  const row = cell?.parentElement;
+  if (action === "merge-cells") {
+    if (!range) return;
+    const merged = mergeSelectedCells(table, range);
+    if (!merged) return;
+    placeCaretAtEnd(merged);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    return;
+  }
+  if (action === "split-cell") {
+    if (!cell) return;
+    const created = splitCell(table, cell);
+    if (!created.length) return;
+    placeCaretAtEnd(cell);
+    __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+    return;
+  }
+  if (action === "add-row" && row) {
+    const clone = row.cloneNode(true);
+    for (const cloneCell of Array.from(clone.querySelectorAll("td,th"))) {
+      cloneCell.innerHTML = "<p><br></p>";
+    }
+    row.after(clone);
+  } else if (action === "add-col" && cell) {
+    const index = Array.from(row?.children ?? []).indexOf(cell);
+    for (const currentRow of Array.from(table.rows)) {
+      const target = currentRow.cells[Math.max(0, index)];
+      const clone = (target ?? currentRow.cells[currentRow.cells.length - 1])?.cloneNode(false);
+      if (!clone) continue;
+      clone.innerHTML = "<p><br></p>";
+      currentRow.insertBefore(clone, target?.nextSibling ?? null);
+    }
+  } else if (action === "del-row" && row && table.rows.length > 1) {
+    row.remove();
+  } else if (action === "del-col" && cell && table.rows[0]?.cells.length > 1) {
+    const index = Array.from(row?.children ?? []).indexOf(cell);
+    for (const currentRow of Array.from(table.rows)) {
+      currentRow.cells[index]?.remove();
+    }
+  } else if (action === "toggle-header") {
+    const thead = table.tHead;
+    if (thead && thead.rows.length) {
+      const headerRow = thead.rows[0];
+      for (const headerCell of Array.from(headerRow.cells)) {
+        const td = document.createElement("td");
+        td.innerHTML = headerCell.innerHTML;
+        headerCell.replaceWith(td);
+      }
+      const tbody = table.tBodies[0] ?? table.createTBody();
+      tbody.insertBefore(headerRow, tbody.firstChild);
+      thead.remove();
+    } else {
+      const firstRow = table.rows[0];
+      if (firstRow) {
+        for (const firstCell of Array.from(firstRow.cells)) {
+          const th = document.createElement("th");
+          th.setAttribute("scope", "col");
+          th.innerHTML = firstCell.innerHTML;
+          firstCell.replaceWith(th);
+        }
+        table.createTHead().appendChild(firstRow);
+      }
+    }
+  } else if (action === "del-table") {
+    const figure = table.closest("figure.fx-table");
+    (figure ?? table).remove();
+  }
+  __privateMethod(this, _FxEditor_instances, afterCommand_fn).call(this);
+};
+handleImageFile_fn = async function(file) {
+  if (!file.type.startsWith("image/")) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "O arquivo selecionado não é uma imagem.");
+    return;
+  }
+  if (file.type === "image/svg+xml") {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "SVG não é permitido por segurança. Use PNG, JPEG, WebP ou GIF.");
+    return;
+  }
+  if (file.size > MAX_IMAGE_BYTES) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "Imagem muito grande (máximo 8 MB).");
+    return;
+  }
+  let src = "";
+  let alt = file.name.replace(/\.[a-z0-9]+$/i, "");
+  try {
+    if (this.uploadImage) {
+      const uploaded = await this.uploadImage(file);
+      if (typeof uploaded === "string") src = uploaded;
+      else {
+        src = uploaded.url;
+        if (uploaded.alt) alt = uploaded.alt;
+      }
+    } else {
+      src = await __privateMethod(this, _FxEditor_instances, fileToDataUrl_fn).call(this, file);
+    }
+  } catch {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "Não foi possível processar a imagem.");
+    return;
+  }
+  if (!src || !sanitizeMediaUrl(src, "img")) {
+    __privateMethod(this, _FxEditor_instances, error_fn).call(this, "A imagem resultante não tem uma URL segura.");
+    return;
+  }
+  __privateMethod(this, _FxEditor_instances, restoreSelection_fn).call(this);
+  __privateMethod(this, _FxEditor_instances, insertImage_fn).call(this, src, alt, "", "100", "center");
+};
+fileToDataUrl_fn = async function(file) {
+  const dataUrl = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ""));
+    reader.onerror = () => reject(new Error("read-error"));
+    reader.readAsDataURL(file);
+  });
+  if (file.type === "image/gif") return dataUrl;
+  return new Promise((resolve) => {
+    const image = new Image();
+    image.onload = () => {
+      const maxWidth = 1600;
+      const scale = Math.min(1, maxWidth / (image.naturalWidth || maxWidth));
+      if (scale >= 1) {
+        resolve(dataUrl);
+        return;
+      }
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.round((image.naturalWidth || maxWidth) * scale);
+      canvas.height = Math.round((image.naturalHeight || maxWidth) * scale);
+      const context = canvas.getContext("2d");
+      if (!context) {
+        resolve(dataUrl);
+        return;
+      }
+      context.drawImage(image, 0, 0, canvas.width, canvas.height);
+      resolve(canvas.toDataURL("image/webp", 0.85));
+    };
+    image.onerror = () => resolve(dataUrl);
+    image.src = dataUrl;
+  });
+};
+error_fn = function(message) {
+  this.dispatchEvent(
+    new CustomEvent("editor-error", {
+      bubbles: true,
+      composed: true,
+      detail: { message }
+    })
+  );
+};
+_FxEditor.styles = `${FENIX_ICON_BASE_CSS}
+${EDITOR_STYLES}`;
+let FxEditor = _FxEditor;
+function defineFxEditor() {
+  return defineElement("fx-editor", FxEditor);
+}
+export {
+  FxEditor,
+  defineFxEditor
+};
+//# sourceMappingURL=editor.js.map