@hkyhy/marsun-components-core 0.1.89 → 0.1.99

package/dist/node_modules/@ckeditor/ckeditor5-widget/dist/index.js

@@ -0,0 +1,1047 @@
+var j = Object.defineProperty;
+var H = (r, e, t) => e in r ? j(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var E = (r, e, t) => H(r, typeof e != "symbol" ? e + "" : e, t);
+import { Plugin as F } from "../../ckeditor5-core/dist/index.js";
+import { MouseObserver as U, PointerObserver as $, ModelTreeWalker as q, ModelDocumentSelection as T } from "../../ckeditor5-engine/dist/index.js";
+import { Delete as N } from "../../ckeditor5-typing/dist/index.js";
+import { keyCodes as P, env as k, getLocalizedArrowKeyCodeDirection as G, compareArrays as v, CKEditorError as Y, isForwardArrowKeyCode as z, getRangeFromMouseEvent as J, toArray as M, Rect as Q, EmitterMixin as X } from "../../ckeditor5-utils/dist/index.js";
+import { IconDragHandle as Z, IconReturnArrow as ee } from "../../ckeditor5-icons/dist/index.js";
+import { IconView as te, Template as W } from "../../ckeditor5-ui/dist/index.js";
+import { Enter as ne, _getCopyOnEnterAttributes as I } from "../../ckeditor5-enter/dist/index.js";
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const oe = /* @__PURE__ */ X();
+var ie = class extends oe {
+  constructor() {
+    super(...arguments);
+    E(this, "_stack", []);
+  }
+  /**
+  * Adds highlight descriptor to the stack.
+  *
+  * @fires change:top
+  */
+  add(e, t) {
+    const n = this._stack, o = n[0];
+    this._insertDescriptor(e);
+    const i = n[0];
+    o !== i && !A(o, i) && this.fire("change:top", {
+      oldDescriptor: o,
+      newDescriptor: i,
+      writer: t
+    });
+  }
+  /**
+  * Removes highlight descriptor from the stack.
+  *
+  * @fires change:top
+  * @param id Id of the descriptor to remove.
+  */
+  remove(e, t) {
+    const n = this._stack, o = n[0];
+    this._removeDescriptor(e);
+    const i = n[0];
+    o !== i && !A(o, i) && this.fire("change:top", {
+      oldDescriptor: o,
+      newDescriptor: i,
+      writer: t
+    });
+  }
+  /**
+  * Inserts a given descriptor in correct place in the stack. It also takes care about updating information
+  * when descriptor with same id is already present.
+  */
+  _insertDescriptor(e) {
+    const t = this._stack, n = t.findIndex((i) => i.id === e.id);
+    if (A(e, t[n])) return;
+    n > -1 && t.splice(n, 1);
+    let o = 0;
+    for (; t[o] && re(t[o], e); ) o++;
+    t.splice(o, 0, e);
+  }
+  /**
+  * Removes descriptor with given id from the stack.
+  *
+  * @param id Descriptor's id.
+  */
+  _removeDescriptor(e) {
+    const t = this._stack, n = t.findIndex((o) => o.id === e);
+    n > -1 && t.splice(n, 1);
+  }
+};
+function A(r, e) {
+  return r && e && r.priority == e.priority && S(r.classes) == S(e.classes);
+}
+function re(r, e) {
+  return r.priority > e.priority ? !0 : r.priority < e.priority ? !1 : S(r.classes) > S(e.classes);
+}
+function S(r) {
+  return Array.isArray(r) ? r.sort().join(",") : r;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const se = "ck-widget", O = "ck-widget_selected";
+function m(r) {
+  return r.is("element") ? !!r.getCustomProperty("widget") : !1;
+}
+function je(r, e, t = {}) {
+  if (!r.is("containerElement"))
+    throw new Y("widget-to-widget-wrong-element-type", null, { element: r });
+  return e.setAttribute("contenteditable", "false", r), e.addClass(se, r), e.setCustomProperty("widget", !0, r), r.getFillerOffset = fe, e.setCustomProperty("widgetLabel", [], r), t.label && de(r, t.label), t.hasSelectionHandle && ge(r, e), ae(r, e), r;
+}
+function ce(r, e, t) {
+  if (e.classes && t.addClass(M(e.classes), r), e.attributes) for (const n in e.attributes) t.setAttribute(n, e.attributes[n], r);
+}
+function le(r, e, t) {
+  if (e.classes && t.removeClass(M(e.classes), r), e.attributes) for (const n in e.attributes) t.removeAttribute(n, r);
+}
+function ae(r, e, t = ce, n = le) {
+  const o = new ie();
+  o.on("change:top", (c, l) => {
+    l.oldDescriptor && n(r, l.oldDescriptor, l.writer), l.newDescriptor && t(r, l.newDescriptor, l.writer);
+  });
+  const i = (c, l, a) => o.add(l, a), s = (c, l, a) => o.remove(l, a);
+  e.setCustomProperty("addHighlight", i, r), e.setCustomProperty("removeHighlight", s, r);
+}
+function de(r, e) {
+  r.getCustomProperty("widgetLabel").push(e);
+}
+function ue(r) {
+  return r.getCustomProperty("widgetLabel").reduce((e, t) => typeof t == "function" ? e ? e + ". " + t() : t() : e ? e + ". " + t : t, "");
+}
+function He(r, e) {
+  return (t, n) => {
+    const { mapper: o, viewPosition: i } = n, s = o.findMappedViewAncestor(i);
+    if (!e(s)) return;
+    const c = o.toModelElement(s);
+    n.modelPosition = r.createPositionAt(c, i.isAtStart ? "before" : "after");
+  };
+}
+function fe() {
+  return null;
+}
+function ge(r, e) {
+  const t = e.createUIElement("div", { class: "ck ck-widget__selection-handle" }, function(n) {
+    const o = this.toDomElement(n), i = new te();
+    return i.set("content", Z), i.render(), o.appendChild(i.element), o;
+  });
+  e.insert(e.createPositionAt(r, 0), t), e.addClass(["ck-widget_with-selection-handle"], r);
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const p = "widget-type-around";
+function b(r, e, t) {
+  return !!r && m(r) && !t.isInline(e);
+}
+function K(r) {
+  return r.closest(".ck-widget__type-around__button");
+}
+function me(r) {
+  return r.classList.contains("ck-widget__type-around__button_before") ? "before" : "after";
+}
+function he(r, e) {
+  const t = r.closest(".ck-widget");
+  return e.mapDomToView(t);
+}
+function w(r) {
+  return r.getAttribute(p);
+}
+function pe(r, e) {
+  let t = e;
+  for (; t && t.is("element") && r.isObject(t); ) t = t.previousSibling;
+  if (!(t != null && t.is("element"))) return [];
+  if (t.isEmpty) {
+    const o = we(t.getAttributes());
+    return Array.from(I(r, o));
+  }
+  const n = t.getChild(t.childCount - 1);
+  return r.isInline(n) ? Array.from(I(r, n.getAttributes())) : [];
+}
+function* we(r) {
+  for (const [e, t] of r)
+    T._isStoreAttributeKey(e) && (yield [T._dropStoreAttributeKeyPrefix(e), t]);
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const V = ["before", "after"], be = new DOMParser().parseFromString(ee, "image/svg+xml").firstChild, x = "ck-widget__type-around_disabled";
+var _e = class extends F {
+  constructor() {
+    super(...arguments);
+    /**
+    * A reference to the model widget element that has the fake caret active
+    * on either side of it. It is later used to remove CSS classes associated with the fake caret
+    * when the widget no longer needs it.
+    */
+    E(this, "_currentFakeCaretModelElement", null);
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "WidgetTypeAround";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [ne, N];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.editing.view;
+    this.on("change:isEnabled", (n, o, i) => {
+      t.change((s) => {
+        for (const c of t.document.roots) i ? s.removeClass(x, c) : s.addClass(x, c);
+      }), i || e.model.change((s) => {
+        s.removeSelectionAttribute(p);
+      });
+    }), this._enableTypeAroundUIInjection(), this._enableInsertingParagraphsOnButtonClick(), this._enableInsertingParagraphsOnEnterKeypress(), this._enableInsertingParagraphsOnTypingKeystroke(), this._enableTypeAroundFakeCaretActivationUsingKeyboardArrows(), this._enableDeleteIntegration(), this._enableInsertContentIntegration(), this._enableInsertObjectIntegration(), this._enableDeleteContentIntegration();
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    super.destroy(), this._currentFakeCaretModelElement = null;
+  }
+  /**
+  * Inserts a new paragraph next to a widget element with the selection anchored in it.
+  *
+  * **Note**: This method is heavily user-oriented and will both focus the editing view and scroll
+  * the viewport to the selection in the inserted paragraph.
+  *
+  * @param widgetModelElement The model widget element next to which a paragraph is inserted.
+  * @param position The position where the paragraph is inserted. Either `'before'` or `'after'` the widget.
+  */
+  _insertParagraph(e, t) {
+    const n = this.editor, { model: o } = n, { schema: i } = o, s = n.editing.view, c = i.getAttributesWithProperty(e, "copyOnReplace", !0), l = pe(i, e);
+    o.change((a) => {
+      n.execute("insertParagraph", {
+        position: n.model.createPositionAt(e, t),
+        attributes: c
+      }) && a.setSelectionAttribute(l);
+    }), s.focus(), s.scrollToTheSelection();
+  }
+  /**
+  * A wrapper for the {@link module:utils/emittermixin~Emitter#listenTo} method that executes the callbacks only
+  * when the plugin {@link #isEnabled is enabled}.
+  *
+  * @param emitter The object that fires the event.
+  * @param event The name of the event.
+  * @param callback The function to be called on event.
+  * @param options Additional options.
+  */
+  _listenToIfEnabled(e, t, n, o) {
+    this.listenTo(e, t, (...i) => {
+      this.isEnabled && n(...i);
+    }, o);
+  }
+  /**
+  * Similar to {@link #_insertParagraph}, this method inserts a paragraph except that it
+  * does not expect a position. Instead, it performs the insertion next to a selected widget
+  * according to the `widget-type-around` model selection attribute value (fake caret position).
+  *
+  * Because this method requires the `widget-type-around` attribute to be set,
+  * the insertion can only happen when the widget's fake caret is active (e.g. activated
+  * using the keyboard).
+  *
+  * @returns Returns `true` when the paragraph was inserted (the attribute was present) and `false` otherwise.
+  */
+  _insertParagraphAccordingToFakeCaretPosition() {
+    const e = this.editor.model.document.selection, t = w(e);
+    if (!t) return !1;
+    const n = e.getSelectedElement();
+    return this._insertParagraph(n, t), !0;
+  }
+  /**
+  * Creates a listener in the editing conversion pipeline that injects the widget type around
+  * UI into every single widget instance created in the editor.
+  *
+  * The UI is delivered as a {@link module:engine/view/uielement~ViewUIElement}
+  * wrapper which renders DOM buttons that users can use to insert paragraphs.
+  */
+  _enableTypeAroundUIInjection() {
+    const e = this.editor, t = e.model.schema, n = e.locale.t, o = {
+      before: n("Insert paragraph before block"),
+      after: n("Insert paragraph after block")
+    };
+    e.editing.downcastDispatcher.on("insert", (i, s, c) => {
+      const l = c.mapper.toViewElement(s.item);
+      l && b(l, s.item, t) && (ye(c.writer, o, l), l.getCustomProperty("widgetLabel").push(() => this.isEnabled ? n("Press Enter to type after or press Shift + Enter to type before the widget") : ""));
+    }, { priority: "low" });
+  }
+  /**
+  * Brings support for the fake caret that appears when either:
+  *
+  * * the selection moves to a widget from a position next to it using arrow keys,
+  * * the arrow key is pressed when the widget is already selected.
+  *
+  * The fake caret lets the user know that they can start typing or just press
+  * <kbd>Enter</kbd> to insert a paragraph at the position next to a widget as suggested by the fake caret.
+  *
+  * The fake caret disappears when the user changes the selection or the editor
+  * gets blurred.
+  *
+  * The whole idea is as follows:
+  *
+  * 1. A user does one of the 2 scenarios described at the beginning.
+  * 2. The "keydown" listener is executed and the decision is made whether to show or hide the fake caret.
+  * 3. If it should show up, the `widget-type-around` model selection attribute is set indicating
+  *    on which side of the widget it should appear.
+  * 4. The selection dispatcher reacts to the selection attribute and sets CSS classes responsible for the
+  *    fake caret on the view widget.
+  * 5. If the fake caret should disappear, the selection attribute is removed and the dispatcher
+  *    does the CSS class clean-up in the view.
+  * 6. Additionally, `change:range` and `FocusTracker#isFocused` listeners also remove the selection
+  *    attribute (the former also removes widget CSS classes).
+  */
+  _enableTypeAroundFakeCaretActivationUsingKeyboardArrows() {
+    const e = this.editor, t = e.model, n = t.document.selection, o = t.schema, i = e.editing.view;
+    this._listenToIfEnabled(i.document, "arrowKey", (c, l) => {
+      this._handleArrowKeyPress(c, l);
+    }, {
+      context: [m, "$text"],
+      priority: "high"
+    }), this._listenToIfEnabled(n, "change:range", (c, l) => {
+      l.directChange && e.model.change((a) => {
+        a.removeSelectionAttribute(p);
+      });
+    }), this._listenToIfEnabled(t.document, "change:data", () => {
+      const c = n.getSelectedElement();
+      if (c) {
+        const l = e.editing.mapper.toViewElement(c);
+        if (b(l, c, o)) return;
+      }
+      e.model.change((l) => {
+        l.removeSelectionAttribute(p);
+      });
+    }), this._listenToIfEnabled(e.editing.downcastDispatcher, "selection", (c, l, a) => {
+      const f = a.writer;
+      if (this._currentFakeCaretModelElement) {
+        const h = a.mapper.toViewElement(this._currentFakeCaretModelElement);
+        h && (f.removeClass(V.map(s), h), this._currentFakeCaretModelElement = null);
+      }
+      const u = l.selection.getSelectedElement();
+      if (!u) return;
+      const d = a.mapper.toViewElement(u);
+      if (!b(d, u, o)) return;
+      const g = w(l.selection);
+      g && (f.addClass(s(g), d), this._currentFakeCaretModelElement = u);
+    }), this._listenToIfEnabled(e.ui.focusTracker, "change:isFocused", (c, l, a) => {
+      a || e.model.change((f) => {
+        f.removeSelectionAttribute(p);
+      });
+    });
+    function s(c) {
+      return `ck-widget_type-around_show-fake-caret_${c}`;
+    }
+  }
+  /**
+  * A listener executed on each "keydown" in the view document, a part of
+  * {@link #_enableTypeAroundFakeCaretActivationUsingKeyboardArrows}.
+  *
+  * It decides whether the arrow keypress should activate the fake caret or not (also whether it should
+  * be deactivated).
+  *
+  * The fake caret activation is done by setting the `widget-type-around` model selection attribute
+  * in this listener, and stopping and preventing the event that would normally be handled by the widget
+  * plugin that is responsible for the regular keyboard navigation near/across all widgets (that
+  * includes inline widgets, which are ignored by the widget type around plugin).
+  */
+  _handleArrowKeyPress(e, t) {
+    const n = this.editor, o = n.model, i = o.document.selection, s = o.schema, c = n.editing.view;
+    if (t.shiftKey) return;
+    const l = t.keyCode, a = z(l, n.locale.contentLanguageDirection), f = c.document.selection.getSelectedElement(), u = n.editing.mapper.toModelElement(f);
+    let d;
+    /* v8 ignore else -- @preserve */
+    b(f, u, s) ? d = this._handleArrowKeyPressOnSelectedWidget(a) : i.isCollapsed ? d = this._handleArrowKeyPressWhenSelectionNextToAWidget(a) : t.shiftKey || (d = this._handleArrowKeyPressWhenNonCollapsedSelection(a)), d && (t.preventDefault(), e.stop());
+  }
+  /**
+  * Handles the keyboard navigation on "keydown" when a widget is currently selected and activates or deactivates
+  * the fake caret for that widget, depending on the current value of the `widget-type-around` model
+  * selection attribute and the direction of the pressed arrow key.
+  *
+  * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+  * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+  * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+  * process the event any further. Returns `false` otherwise.
+  */
+  _handleArrowKeyPressOnSelectedWidget(e) {
+    const t = this.editor.model, n = t.document.selection, o = w(n);
+    return t.change((i) => {
+      if (o) {
+        if (o !== (e ? "after" : "before"))
+          return i.removeSelectionAttribute(p), !0;
+      } else
+        return i.setSelectionAttribute(p, e ? "after" : "before"), !0;
+      return !1;
+    });
+  }
+  /**
+  * Handles the keyboard navigation on "keydown" when **no** widget is selected but the selection is **directly** next
+  * to one and upon the fake caret should become active for this widget upon arrow keypress
+  * (AKA entering/selecting the widget).
+  *
+  * **Note**: This code mirrors the implementation from the widget plugin but also adds the selection attribute.
+  * Unfortunately, there is no safe way to let the widget plugin do the selection part first and then just set the
+  * selection attribute here in the widget type around plugin. This is why this code must duplicate some from the widget plugin.
+  *
+  * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+  * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+  * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+  * process the event any further. Returns `false` otherwise.
+  */
+  _handleArrowKeyPressWhenSelectionNextToAWidget(e) {
+    const t = this.editor, n = t.model, o = n.schema, i = t.plugins.get("Widget"), s = i._getObjectElementNextToSelection(e), c = t.editing.mapper.toViewElement(s);
+    return b(c, s, o) ? (n.change((l) => {
+      i._setSelectionOverElement(s), l.setSelectionAttribute(p, e ? "before" : "after");
+    }), !0) : !1;
+  }
+  /**
+  * Handles the keyboard navigation on "keydown" when a widget is currently selected (together with some other content)
+  * and the widget is the first or last element in the selection. It activates or deactivates the fake caret for that widget.
+  *
+  * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+  * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+  * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+  * process the event any further. Returns `false` otherwise.
+  */
+  _handleArrowKeyPressWhenNonCollapsedSelection(e) {
+    const t = this.editor, n = t.model, o = n.schema, i = t.editing.mapper, s = n.document.selection, c = e ? s.getLastPosition().nodeBefore : s.getFirstPosition().nodeAfter, l = i.toViewElement(c);
+    return b(l, c, o) ? (n.change((a) => {
+      a.setSelection(c, "on"), a.setSelectionAttribute(p, e ? "after" : "before");
+    }), !0) : !1;
+  }
+  /**
+  * Registers a `mousedown` listener for the view document which intercepts events
+  * coming from the widget type around UI, which happens when a user clicks one of the buttons
+  * that insert a paragraph next to a widget.
+  */
+  _enableInsertingParagraphsOnButtonClick() {
+    const e = this.editor, t = e.editing.view;
+    this._listenToIfEnabled(t.document, "mousedown", (n, o) => {
+      const i = K(o.domTarget);
+      if (!i) return;
+      const s = me(i), c = he(i, t.domConverter), l = e.editing.mapper.toModelElement(c);
+      this._insertParagraph(l, s), o.preventDefault(), n.stop();
+    });
+  }
+  /**
+  * Creates the <kbd>Enter</kbd> key listener on the view document that allows the user to insert a paragraph
+  * near the widget when either:
+  *
+  * * The fake caret was first activated using the arrow keys,
+  * * The entire widget is selected in the model.
+  *
+  * In the first case, the new paragraph is inserted according to the `widget-type-around` selection
+  * attribute (see {@link #_handleArrowKeyPress}).
+  *
+  * In the second case, the new paragraph is inserted based on whether a soft (<kbd>Shift</kbd>+<kbd>Enter</kbd>) keystroke
+  * was pressed or not.
+  */
+  _enableInsertingParagraphsOnEnterKeypress() {
+    const e = this.editor, t = e.model.document.selection, n = e.editing.view;
+    this._listenToIfEnabled(n.document, "enter", (o, i) => {
+      if (o.eventPhase != "atTarget") return;
+      const s = t.getSelectedElement(), c = e.editing.mapper.toViewElement(s), l = e.model.schema;
+      let a;
+      this._insertParagraphAccordingToFakeCaretPosition() ? a = !0 : b(c, s, l) && (this._insertParagraph(s, i.isSoft ? "before" : "after"), a = !0), a && (i.preventDefault(), o.stop());
+    }, { context: m });
+  }
+  /**
+  * Similar to the {@link #_enableInsertingParagraphsOnEnterKeypress}, it allows the user
+  * to insert a paragraph next to a widget when the fake caret was activated using arrow
+  * keys but it responds to typing instead of <kbd>Enter</kbd>.
+  *
+  * Listener enabled by this method will insert a new paragraph according to the `widget-type-around`
+  * model selection attribute as the user simply starts typing, which creates the impression that the fake caret
+  * behaves like a real one rendered by the browser (AKA your text appears where the caret was).
+  *
+  * **Note**: At the moment this listener creates 2 undo steps: one for the `insertParagraph` command
+  * and another one for actual typing. It is not a disaster but this may need to be fixed
+  * sooner or later.
+  */
+  _enableInsertingParagraphsOnTypingKeystroke() {
+    const e = this.editor.editing.view.document;
+    this._listenToIfEnabled(e, "insertText", (t, n) => {
+      this._insertParagraphAccordingToFakeCaretPosition() && (n.selection = e.selection);
+    }, { priority: "high" }), k.isAndroid ? this._listenToIfEnabled(e, "keydown", (t, n) => {
+      n.keyCode == 229 && this._insertParagraphAccordingToFakeCaretPosition();
+    }) : this._listenToIfEnabled(e, "compositionstart", () => {
+      this._insertParagraphAccordingToFakeCaretPosition();
+    }, { priority: "highest" });
+  }
+  /**
+  * It creates a "delete" event listener on the view document to handle cases when the <kbd>Delete</kbd> or <kbd>Backspace</kbd>
+  * is pressed and the fake caret is currently active.
+  *
+  * The fake caret should create an illusion of a real browser caret so that when it appears before or after
+  * a widget, pressing <kbd>Delete</kbd> or <kbd>Backspace</kbd> should remove a widget or delete the content
+  * before or after a widget (depending on the content surrounding the widget).
+  */
+  _enableDeleteIntegration() {
+    const e = this.editor, t = e.editing.view, n = e.model, o = n.schema;
+    this._listenToIfEnabled(t.document, "delete", (i, s) => {
+      if (i.eventPhase != "atTarget") return;
+      const c = w(n.document.selection);
+      if (!c) return;
+      const l = s.direction, a = n.document.selection.getSelectedElement(), f = c === "before", u = l == "forward";
+      if (f === u) e.execute("delete", { selection: n.createSelection(a, "on") });
+      else {
+        const d = o.getNearestSelectionRange(n.createPositionAt(a, c), l);
+        if (d) if (!d.isCollapsed) n.change((g) => {
+          g.setSelection(d), e.execute(u ? "deleteForward" : "delete");
+        });
+        else {
+          const g = n.createSelection(d.start);
+          if (n.modifySelection(g, { direction: l }), !g.focus.isEqual(d.start)) n.change((h) => {
+            h.setSelection(d), e.execute(u ? "deleteForward" : "delete");
+          });
+          else {
+            const h = Ae(o, d.start.parent);
+            n.deleteContent(n.createSelection(h, "on"), { doNotAutoparagraph: !0 });
+          }
+        }
+      }
+      s.preventDefault(), i.stop();
+    }, { context: m });
+  }
+  /**
+  * Attaches the {@link module:engine/model/model~Model#event:insertContent} event listener that, for instance, allows the user to paste
+  * content near a widget when the fake caret is first activated using the arrow keys.
+  *
+  * The content is inserted according to the `widget-type-around` selection attribute (see {@link #_handleArrowKeyPress}).
+  */
+  _enableInsertContentIntegration() {
+    const e = this.editor, t = this.editor.model, n = t.document.selection;
+    this._listenToIfEnabled(e.model, "insertContent", (o, [i, s]) => {
+      if (s && !s.is("documentSelection")) return;
+      const c = w(n);
+      if (c)
+        return o.stop(), t.change((l) => {
+          const a = n.getSelectedElement(), f = t.createPositionAt(a, c), u = l.createSelection(f), d = t.insertContent(i, u);
+          return l.setSelection(u), d;
+        });
+    }, { priority: "high" });
+  }
+  /**
+  * Attaches the {@link module:engine/model/model~Model#event:insertObject} event listener that modifies the
+  * `options.findOptimalPosition`parameter to position of fake caret in relation to selected element
+  * to reflect user's intent of desired insertion position.
+  *
+  * The object is inserted according to the `widget-type-around` selection attribute (see {@link #_handleArrowKeyPress}).
+  */
+  _enableInsertObjectIntegration() {
+    const e = this.editor, t = this.editor.model.document.selection;
+    this._listenToIfEnabled(e.model, "insertObject", (n, o) => {
+      const [, i, s = {}] = o;
+      if (i && !i.is("documentSelection")) return;
+      const c = w(t);
+      c && (s.findOptimalPosition = c, o[3] = s);
+    }, { priority: "high" });
+  }
+  /**
+  * Attaches the {@link module:engine/model/model~Model#event:deleteContent} event listener to block the event when the fake
+  * caret is active.
+  *
+  * This is required for cases that trigger {@link module:engine/model/model~Model#deleteContent `model.deleteContent()`}
+  * before calling {@link module:engine/model/model~Model#insertContent `model.insertContent()`} like, for instance,
+  * plain text pasting.
+  */
+  _enableDeleteContentIntegration() {
+    const e = this.editor, t = this.editor.model.document.selection;
+    this._listenToIfEnabled(e.model, "deleteContent", (n, [o]) => {
+      o && !o.is("documentSelection") || w(t) && n.stop();
+    }, { priority: "high" });
+  }
+};
+function ye(r, e, t) {
+  const n = r.createUIElement("div", { class: "ck ck-reset_all ck-widget__type-around" }, function(o) {
+    const i = this.toDomElement(o);
+    return Ee(i, e), Se(i), i;
+  });
+  r.insert(r.createPositionAt(t, "end"), n);
+}
+function Ee(r, e) {
+  for (const t of V) {
+    const n = new W({
+      tag: "div",
+      attributes: {
+        class: [
+          "ck",
+          "ck-widget__type-around__button",
+          `ck-widget__type-around__button_${t}`
+        ],
+        title: e[t],
+        "aria-hidden": "true"
+      },
+      children: [r.ownerDocument.importNode(be, !0)]
+    });
+    r.appendChild(n.render());
+  }
+}
+function Se(r) {
+  const e = new W({
+    tag: "div",
+    attributes: { class: ["ck", "ck-widget__type-around__fake-caret"] }
+  });
+  r.appendChild(e.render());
+}
+function Ae(r, e) {
+  let t = e;
+  for (const n of e.getAncestors({ parentFirst: !0 })) {
+    if (n.childCount > 1 || r.isLimit(n)) break;
+    t = n;
+  }
+  return t;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function Pe(r) {
+  const e = r.model;
+  return (t, n) => {
+    const o = n.keyCode == P.arrowup, i = n.keyCode == P.arrowdown, s = n.shiftKey, c = e.document.selection;
+    if (!o && !i) return;
+    const l = i, a = ke(r, c, l);
+    if (a) {
+      if (a.isCollapsed) {
+        if (c.isCollapsed) return;
+        if (s) return;
+      }
+      (a.isCollapsed || Ce(r, a, l)) && (e.change((f) => {
+        const u = l ? a.end : a.start;
+        if (s) {
+          const d = e.createSelection(c.anchor);
+          d.setFocus(u), f.setSelection(d);
+        } else f.setSelection(u);
+      }), t.stop(), n.preventDefault(), n.stopPropagation());
+    }
+  };
+}
+function ke(r, e, t) {
+  const n = r.model;
+  if (t) {
+    const o = e.focus, i = D(n, o, "forward");
+    if (!i) return;
+    const s = n.createRange(o, i), c = R(n.schema, s, "backward");
+    /* v8 ignore else -- @preserve */
+    if (c) return n.createRange(o, c);
+  } else {
+    const o = e.focus, i = D(n, o, "backward");
+    if (!i) return;
+    const s = n.createRange(i, o), c = R(n.schema, s, "forward");
+    /* v8 ignore else -- @preserve */
+    if (c) return n.createRange(c, o);
+  }
+}
+function D(r, e, t) {
+  const n = r.schema, o = r.createRangeIn(e.root), i = t == "forward" ? "elementStart" : "elementEnd";
+  for (const { previousPosition: s, item: c, type: l } of o.getWalker({
+    startPosition: e,
+    direction: t
+  })) {
+    if (n.isLimit(c) && !n.isInline(c)) return s;
+    if (l == i && n.isBlock(c)) return null;
+  }
+  return null;
+}
+function R(r, e, t) {
+  const n = t == "backward" ? e.end : e.start;
+  if (r.checkChild(n, "$text")) return n;
+  for (const { nextPosition: o } of e.getWalker({ direction: t })) if (r.checkChild(o, "$text")) return o;
+}
+function Ce(r, e, t) {
+  const n = r.model, o = r.view.domConverter;
+  if (t) {
+    const a = n.createSelection(e.start);
+    n.modifySelection(a), !a.focus.isAtEnd && !e.start.isEqual(a.focus) && (e = n.createRange(a.focus, e.end));
+  }
+  const i = r.mapper.toViewRange(e), s = o.viewRangeToDom(i), c = Q.getDomRangeRects(s);
+  let l;
+  for (const a of c) {
+    if (l === void 0) {
+      l = Math.round(a.bottom);
+      continue;
+    }
+    if (Math.round(a.top) >= l) return !1;
+    l = Math.max(l, Math.round(a.bottom));
+  }
+  return !0;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var Ue = class extends F {
+  constructor() {
+    super(...arguments);
+    /**
+    * Holds previously selected widgets.
+    */
+    E(this, "_previouslySelected", /* @__PURE__ */ new Set());
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "Widget";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [_e, N];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.editing.view, n = t.document, o = e.t;
+    this.editor.editing.downcastDispatcher.on("selection", (i, s, c) => {
+      const l = c.writer, a = s.selection;
+      if (a.isCollapsed) return;
+      const f = a.getSelectedElement();
+      if (!f) return;
+      const u = e.editing.mapper.toViewElement(f);
+      m(u) && c.consumable.consume(a, "selection") && l.setSelection(l.createRangeOn(u), {
+        fake: !0,
+        label: ue(u)
+      });
+    }), this.editor.editing.downcastDispatcher.on("selection", (i, s, c) => {
+      this._clearPreviouslySelectedWidgets(c.writer);
+      const l = c.writer, a = l.document.selection;
+      let f = null;
+      for (const u of a.getRanges()) for (const d of u) {
+        const g = d.item;
+        m(g) && !xe(g, f) && (l.addClass(O, g), this._previouslySelected.add(g), f = g);
+      }
+    }, { priority: "low" }), t.addObserver(U), t.addObserver($), this.listenTo(n, "mousedown", (...i) => this._onMousedown(...i)), this.listenTo(n, "pointerdown", (...i) => this._onPointerdown(...i)), this.listenTo(n, "arrowKey", (...i) => {
+      this._handleSelectionChangeOnArrowKeyPress(...i);
+    }, { context: [m, "$text"] }), this.listenTo(n, "arrowKey", (...i) => {
+      this._preventDefaultOnArrowKeyPress(...i);
+    }, { context: "$root" }), this.listenTo(n, "arrowKey", Pe(this.editor.editing), { context: "$text" }), this.listenTo(n, "delete", (i, s) => {
+      this._handleDelete(s.direction == "forward") && (s.preventDefault(), i.stop());
+    }, { context: "$root" }), this.listenTo(n, "tab", (i, s) => {
+      this._selectNextEditable(s.shiftKey ? "backward" : "forward") && (t.scrollToTheSelection(), s.preventDefault(), i.stop());
+    }, {
+      context: (i) => m(i) || i.is("editableElement"),
+      priority: "low"
+    }), this.listenTo(n, "keydown", (i, s) => {
+      s.keystroke == P.esc && this._selectAncestorWidget() && (s.preventDefault(), i.stop());
+    }, {
+      context: (i) => i.is("editableElement"),
+      priority: "low"
+    }), e.accessibility.addKeystrokeInfoGroup({
+      id: "widget",
+      label: o("Keystrokes that can be used when a widget is selected (for example: image, table, etc.)"),
+      keystrokes: [
+        {
+          label: o("Move focus from an editable area back to the parent widget"),
+          keystroke: "Esc"
+        },
+        {
+          label: o("Insert a new paragraph directly after a widget"),
+          keystroke: "Enter"
+        },
+        {
+          label: o("Insert a new paragraph directly before a widget"),
+          keystroke: "Shift+Enter"
+        },
+        {
+          label: o("Move the caret to allow typing directly before a widget"),
+          keystroke: [["arrowup"], ["arrowleft"]]
+        },
+        {
+          label: o("Move the caret to allow typing directly after a widget"),
+          keystroke: [["arrowdown"], ["arrowright"]]
+        }
+      ]
+    });
+  }
+  /**
+  * Handles {@link module:engine/view/document~ViewDocument#event:mousedown mousedown} events on widget elements.
+  */
+  _onMousedown(e, t) {
+    const n = t.target;
+    n && t.domEvent.detail >= 3 && this._selectBlockContent(n) && t.preventDefault();
+  }
+  /**
+  * Handles {@link module:engine/view/document~ViewDocument#event:pointerdown pointerdown} events on widget elements.
+  */
+  _onPointerdown(e, t) {
+    if (!t.domEvent.isPrimary || K(t.domTarget)) return;
+    const n = this.editor, o = n.editing.view, i = o.document;
+    let s = t.target;
+    if (!s) return;
+    if (!m(s)) {
+      const l = Ie(s);
+      if (!l) return;
+      if (m(l)) s = l;
+      else {
+        const a = Oe(o, t);
+        if (a && m(a)) s = a;
+        else return;
+      }
+    }
+    (k.isAndroid || k.isiOS) && t.preventDefault(), i.isFocused || o.focus();
+    const c = n.editing.mapper.toModelElement(s);
+    this._setSelectionOverElement(c);
+  }
+  /**
+  * Selects entire block content, e.g. on triple click it selects entire paragraph.
+  */
+  _selectBlockContent(e) {
+    const t = this.editor, n = t.model, o = t.editing.mapper, i = n.schema, s = o.findMappedViewAncestor(this.editor.editing.view.createPositionAt(e, 0)), c = De(o.toModelElement(s), n.schema);
+    return c ? (n.change((l) => {
+      const a = i.isLimit(c) ? null : Re(l.createPositionAfter(c), i), f = l.createPositionAt(c, 0), u = a ? l.createPositionAt(a, 0) : l.createPositionAt(c, "end");
+      l.setSelection(l.createRange(f, u));
+    }), !0) : !1;
+  }
+  /**
+  * Handles {@link module:engine/view/document~ViewDocument#event:keydown keydown} events and changes
+  * the model selection when:
+  *
+  * * arrow key is pressed when the widget is selected,
+  * * the selection is next to a widget and the widget should become selected upon the arrow key press.
+  *
+  * See {@link #_preventDefaultOnArrowKeyPress}.
+  */
+  _handleSelectionChangeOnArrowKeyPress(e, t) {
+    const n = t.keyCode, o = this.editor.model, i = o.schema, s = o.document.selection, c = s.getSelectedElement(), l = G(n, this.editor.locale.contentLanguageDirection), a = l == "down" || l == "right", f = l == "up" || l == "down";
+    if (!t.shiftKey && !s.isCollapsed) {
+      if (Te(s, i)) {
+        const y = a ? s.getLastPosition() : s.getFirstPosition(), C = i.getNearestSelectionRange(y, a ? "forward" : "backward");
+        C && (o.change((L) => {
+          L.setSelection(C);
+        }), t.preventDefault(), e.stop());
+      }
+      return;
+    }
+    const u = ve(o, a), d = o.createSelection(u);
+    if (o.modifySelection(d, { direction: a ? "forward" : "backward" }), d.isEqual(u)) return;
+    d.focus.isTouching(u.focus) && i.checkChild(d.focus.parent, "$text") && (a ? !d.focus.isAtEnd : !d.focus.isAtStart) && o.modifySelection(d, { direction: a ? "forward" : "backward" });
+    const g = a ? u.focus.nodeBefore : u.focus.nodeAfter, h = d.focus.nodeBefore, B = d.focus.nodeAfter, _ = a ? h : B;
+    if (t.shiftKey)
+      (c && i.isObject(c) || _ && i.isObject(_) || g && i.isObject(g)) && (o.change((y) => {
+        y.setSelection(d);
+      }), t.preventDefault(), e.stop());
+    else if (_ && i.isObject(_)) {
+      if (i.isInline(_) && f) return;
+      o.change((y) => {
+        y.setSelection(_, "on");
+      }), t.preventDefault(), e.stop();
+    }
+  }
+  /**
+  * Handles {@link module:engine/view/document~ViewDocument#event:keydown keydown} events and prevents
+  * the default browser behavior to make sure the fake selection is not being moved from a fake selection
+  * container.
+  *
+  * See {@link #_handleSelectionChangeOnArrowKeyPress}.
+  */
+  _preventDefaultOnArrowKeyPress(e, t) {
+    const n = this.editor.model, o = n.schema, i = n.document.selection.getSelectedElement();
+    i && o.isObject(i) && (t.preventDefault(), e.stop());
+  }
+  /**
+  * Handles delete keys: backspace and delete.
+  *
+  * @param isForward Set to true if delete was performed in forward direction.
+  * @returns Returns `true` if keys were handled correctly.
+  */
+  _handleDelete(e) {
+    const t = this.editor.model.document.selection;
+    if (!this.editor.model.canEditAt(t) || !t.isCollapsed) return;
+    const n = this._getObjectElementNextToSelection(e);
+    if (n)
+      return this.editor.model.change((o) => {
+        let i = t.anchor.parent;
+        for (; i.isEmpty; ) {
+          const s = i;
+          i = s.parent, o.remove(s);
+        }
+        this._setSelectionOverElement(n);
+      }), !0;
+  }
+  /**
+  * Sets {@link module:engine/model/selection~ModelSelection document's selection} over given element.
+  *
+  * @internal
+  */
+  _setSelectionOverElement(e) {
+    this.editor.model.change((t) => {
+      t.setSelection(t.createRangeOn(e));
+    });
+  }
+  /**
+  * Checks if {@link module:engine/model/element~ModelElement element} placed next to the current
+  * {@link module:engine/model/selection~ModelSelection model selection} exists and is marked in
+  * {@link module:engine/model/schema~ModelSchema schema} as `object`.
+  *
+  * @internal
+  * @param forward Direction of checking.
+  */
+  _getObjectElementNextToSelection(e) {
+    const t = this.editor.model, n = t.schema, o = t.document.selection, i = t.createSelection(o);
+    if (t.modifySelection(i, { direction: e ? "forward" : "backward" }), i.isEqual(o)) return null;
+    const s = e ? i.focus.nodeBefore : i.focus.nodeAfter;
+    return s && n.isObject(s) ? s : null;
+  }
+  /**
+  * Removes CSS class from previously selected widgets.
+  */
+  _clearPreviouslySelectedWidgets(e) {
+    for (const t of this._previouslySelected) e.removeClass(O, t);
+    this._previouslySelected.clear();
+  }
+  /**
+  * Moves the document selection into the next editable or block widget.
+  */
+  _selectNextEditable(e) {
+    const t = this.editor.editing, n = t.view, o = this.editor.model, i = n.document.selection, s = o.document.selection;
+    let c;
+    if (s.rangeCount > 1) {
+      const a = s.isBackward ? s.getFirstRange() : s.getLastRange();
+      c = t.mapper.toViewPosition(e == "forward" ? a.end : a.start);
+    } else c = e == "forward" ? i.getFirstPosition() : i.getLastPosition();
+    const l = this._findNextFocusRange(c, e);
+    return l ? (o.change((a) => {
+      a.setSelection(l);
+    }), !0) : !1;
+  }
+  /**
+  * Looks for next focus point in the document starting from the given view position and direction.
+  * The focus point is either a block widget or an editable.
+  *
+  * @internal
+  */
+  _findNextFocusRange(e, t) {
+    const n = this.editor.editing, o = n.view, i = this.editor.model, s = o.document.selection, c = s.editableElement, l = c.getPath();
+    let a = s.getSelectedElement();
+    a && !m(a) && (a = null);
+    const f = t == "forward" ? o.createRange(e, o.createPositionAt(e.root, "end")) : o.createRange(o.createPositionAt(e.root, 0), e);
+    for (const { nextPosition: u } of f.getWalker({ direction: t })) {
+      const d = u.parent;
+      if (m(d) && d != a) {
+        const g = n.mapper.toModelElement(d);
+        if (!i.schema.isBlock(g)) continue;
+        if (v(l, d.getPath()) != "extension") return i.createRangeOn(g);
+      } else if (d.is("editableElement")) {
+        if (d == c && !a) continue;
+        const g = n.mapper.toModelPosition(u), h = i.schema.getNearestSelectionRange(g, t);
+        if (!h) continue;
+        return d == c && a ? h : v(l, d.getPath()) != "extension" ? i.createRangeIn(i.schema.getLimitElement(h)) : h;
+      }
+    }
+    return null;
+  }
+  /**
+  * Updates the document selection so that it selects first ancestor widget.
+  */
+  _selectAncestorWidget() {
+    const e = this.editor, t = e.editing.mapper, n = e.editing.view.document.selection.getFirstPosition().parent, o = (n.is("$text") ? n.parent : n).findAncestor(m);
+    if (!o) return !1;
+    const i = t.toModelElement(o);
+    return i ? (e.model.change((s) => {
+      s.setSelection(i, "on");
+    }), !0) : !1;
+  }
+};
+function Te(r, e) {
+  const t = r.getFirstPosition(), n = r.getLastPosition(), o = t.nodeAfter, i = n.nodeBefore;
+  return !!o && e.isObject(o) || !!i && e.isObject(i);
+}
+function ve(r, e) {
+  const t = r.document.selection, n = t.getSelectedElement(), o = w(t);
+  return n && o == "before" ? r.createSelection(n, "before") : n && o == "after" ? r.createSelection(n, "after") : r.createSelection(t.getRanges(), { backward: n && r.schema.isObject(n) ? !e : t.isBackward });
+}
+function Ie(r) {
+  let e = r;
+  for (; e; ) {
+    if (e.is("editableElement") || m(e)) return e;
+    e = e.parent;
+  }
+  return null;
+}
+function Oe(r, e) {
+  const t = J(e.domEvent);
+  let n;
+  if (t ? n = r.domConverter.domRangeToView(t) : n = r.createRange(r.createPositionAt(e.target, 0)), !n) return null;
+  const o = n.start;
+  if (!o.parent) return null;
+  let i = o.parent;
+  if (o.parent.is("editableElement")) {
+    /* v8 ignore else -- @preserve */
+    o.isAtEnd && o.nodeBefore ? i = o.nodeBefore : o.isAtStart && o.nodeAfter && (i = o.nodeAfter);
+  }
+  return i.is("$text") ? i.parent : i;
+}
+function xe(r, e) {
+  return e ? Array.from(r.getAncestors()).includes(e) : !1;
+}
+function De(r, e) {
+  for (const t of r.getAncestors({
+    includeSelf: !0,
+    parentFirst: !0
+  })) {
+    if (e.checkChild(t, "$text")) return t;
+    if (e.isLimit(t) && !e.isObject(t)) break;
+  }
+  return null;
+}
+function Re(r, e) {
+  const t = new q({ startPosition: r });
+  for (const { item: n } of t) {
+    if (e.isLimit(n) || !n.is("element")) return null;
+    if (e.checkChild(n, "$text")) return n;
+  }
+  return null;
+}
+export {
+  se as WIDGET_CLASS_NAME,
+  O as WIDGET_SELECTED_CLASS_NAME,
+  Ue as Widget,
+  ie as WidgetHighlightStack,
+  _e as WidgetTypeAround,
+  p as _WIDGET_TYPE_AROUND_SELECTION_ATTRIBUTE,
+  K as _getClosestWidgetTypeAroundDomButton,
+  he as _getClosestWidgetViewElement,
+  me as _getWidgetTypeAroundButtonPosition,
+  w as _getWidgetTypeAroundFakeCaretPosition,
+  ue as getLabel,
+  b as isTypeAroundWidget,
+  m as isWidget,
+  ae as setHighlightHandling,
+  de as setLabel,
+  je as toWidget,
+  Pe as verticalWidgetNavigationHandler,
+  He as viewToModelPositionOutsideModelElement
+};
+//# sourceMappingURL=index.js.map