@hkyhy/marsun-components-core 0.1.89 → 0.1.99

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

@@ -0,0 +1,1256 @@
+var te = Object.defineProperty;
+var re = (a, e, t) => e in a ? te(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var g = (a, e, t) => re(a, typeof e != "symbol" ? e + "" : e, t);
+import { Plugin as b } from "../../ckeditor5-core/dist/index.js";
+import { uid as q, EventInfo as j, delay as H, DomEmitterMixin as A, env as f, global as h, createElement as V, Rect as _, getRangeFromMouseEvent as ne, ResizeObserver as ie, toUnit as oe } from "../../ckeditor5-utils/dist/index.js";
+import { PointerObserver as se, ModelLiveRange as E, DomEventObserver as ae, ViewDataTransfer as le, ModelRange as de } from "../../ckeditor5-engine/dist/index.js";
+import { throttle as B } from "../../../es-toolkit/dist/compat/function/throttle.js";
+import { mapValues as ce } from "../../../es-toolkit/dist/compat/object/mapValues.js";
+import { Widget as ge, isWidget as k } from "../../ckeditor5-widget/dist/index.js";
+import { View as pe } from "../../ckeditor5-ui/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
+*/
+function me(a) {
+  return a = a.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r?\n\r?\n/g, "</p><p>").replace(/\r?\n/g, "<br>").replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;").replace(/^\s/, "&nbsp;").replace(/\s$/, "&nbsp;").replace(/\s\s/g, " &nbsp;"), (a.includes("</p><p>") || a.includes("<br>")) && (a = `<p>${a}</p>`), a;
+}
+/**
+* @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 v = class extends ae {
+  constructor(e) {
+    super(e);
+    g(this, "domEventType", [
+      "paste",
+      "copy",
+      "cut",
+      "drop",
+      "dragover",
+      "dragstart",
+      "dragend",
+      "dragenter",
+      "dragleave"
+    ]);
+    const t = this.document;
+    this.listenTo(t, "paste", n("clipboardInput"), { priority: "low" }), this.listenTo(t, "drop", n("clipboardInput"), { priority: "low" }), this.listenTo(t, "dragover", n("dragging"), { priority: "low" });
+    function n(r) {
+      return (i, s) => {
+        s.preventDefault();
+        const o = s.dropRange ? [s.dropRange] : null, l = s.dataTransfer, d = new j(t, r);
+        let c = "";
+        l.getData("text/html") ? c = l.getData("text/html") : l.getData("text/plain") && (c = me(l.getData("text/plain"))), t.fire(d, {
+          dataTransfer: l,
+          content: c,
+          method: i.name,
+          targetRanges: o,
+          target: s.target,
+          domEvent: s.domEvent
+        }), d.stop.called && s.stopPropagation();
+      };
+    }
+  }
+  onDomEvent(e) {
+    const t = "clipboardData" in e ? e.clipboardData : e.dataTransfer, n = e.type == "drop" || e.type == "paste", r = { dataTransfer: new le(t, { cacheFiles: n }) };
+    if (e.type == "drop" || e.type == "dragover") {
+      const i = ne(e);
+      r.dropRange = i && this.view.domConverter.domRangeToView(i);
+    }
+    this.fire(e.type, e, 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
+*/
+function ue(a) {
+  return a.replace(/<span(?: class="Apple-converted-space"|)>(\s+)<\/span>/g, (e, t) => t.length == 1 ? " " : t).replace(/<!--[\s\S]*?-->/g, "");
+}
+/**
+* @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 L = ["figcaption", "li"], U = ["ol", "ul"];
+function G(a, e) {
+  if (e.is("$text") || e.is("$textProxy")) return e.data;
+  if (e.is("element", "img") && e.hasAttribute("alt")) return e.getAttribute("alt");
+  if (e.is("element", "br")) return `
+`;
+  let t = "", n = null;
+  for (const r of e.getChildren())
+    t += he(r, n) + G(a, r), n = r;
+  if (e.is("rawElement")) {
+    const r = document.implementation.createHTMLDocument("").createElement("div");
+    e.render(r, a), t += X(r);
+  }
+  return t;
+}
+function X(a) {
+  let e = "";
+  if (a.nodeType === Node.TEXT_NODE) return a.textContent;
+  if (a.tagName === "BR") return `
+`;
+  for (const t of a.childNodes) e += X(t);
+  return e;
+}
+function he(a, e) {
+  return e ? a.is("element", "li") && !a.isEmpty && a.getChild(0).is("containerElement") || U.includes(a.name) && U.includes(e.name) ? `
+
+` : !a.is("containerElement") && !e.is("containerElement") ? "" : L.includes(a.name) || L.includes(e.name) ? `
+` : a.is("element") && a.getCustomProperty("dataPipeline:transparentRendering") || e.is("element") && e.getCustomProperty("dataPipeline:transparentRendering") ? "" : `
+
+` : "";
+}
+/**
+* @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 Y = class extends b {
+  constructor() {
+    super(...arguments);
+    /**
+    * Map of marker names that can be copied.
+    *
+    * @internal
+    */
+    g(this, "_markersToCopy", /* @__PURE__ */ new Map());
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ClipboardMarkersUtils";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * Registers marker name as copyable in clipboard pipeline.
+  *
+  * @param markerName Name of marker that can be copied.
+  * @param config Configuration that describes what can be performed on specified marker.
+  * @internal
+  */
+  _registerMarkerToCopy(e, t) {
+    this._markersToCopy.set(e, t);
+  }
+  /**
+  * Performs copy markers on provided selection and paste it to fragment returned from `getCopiedFragment`.
+  *
+  * 	1. Picks all markers in provided selection.
+  * 	2. Inserts fake markers to document.
+  * 	3. Gets copied selection fragment from document.
+  * 	4. Removes fake elements from fragment and document.
+  * 	5. Inserts markers in the place of removed fake markers.
+  *
+  * Due to selection modification, when inserting items, `getCopiedFragment` must *always* operate on `writer.model.document.selection'.
+  * Do not use any other custom selection object within callback, as this will lead to out-of-bounds exceptions in rare scenarios.
+  *
+  * @param action Type of clipboard action.
+  * @param selection Selection to be checked.
+  * @param getCopiedFragment	Callback that performs copy of selection and returns it as fragment.
+  * @internal
+  */
+  _copySelectedFragmentWithMarkers(e, t, n = (r) => r.model.getSelectedContent(r.model.document.selection)) {
+    return this.editor.model.change((r) => {
+      const i = r.model.document.selection;
+      r.setSelection(t);
+      const s = this._insertFakeMarkersIntoSelection(r, r.model.document.selection, e), o = n(r), l = this._removeFakeMarkersInsideElement(r, o);
+      for (const [d, c] of Object.entries(s)) {
+        l[d] || (l[d] = r.createRangeIn(o));
+        for (const p of c) r.remove(p);
+      }
+      o.markers.clear();
+      for (const [d, c] of Object.entries(l)) o.markers.set(d, c);
+      return r.setSelection(i), o;
+    });
+  }
+  /**
+  * Performs paste of markers on already pasted element.
+  *
+  * 	1. Inserts fake markers that are present in fragment element (such fragment will be processed in `getPastedDocumentElement`).
+  * 	2. Calls `getPastedDocumentElement` and gets element that is inserted into root model.
+  * 	3. Removes all fake markers present in transformed element.
+  * 	4. Inserts new markers with removed fake markers ranges into pasted fragment.
+  *
+  * There are multiple edge cases that have to be considered before calling this function:
+  *
+  * 	* `markers` are inserted into the same element that must be later transformed inside `getPastedDocumentElement`.
+  * 	* Fake marker elements inside `getPastedDocumentElement` can be cloned, but their ranges cannot overlap.
+  * 	* If `duplicateOnPaste` is `true` in marker config then associated marker ID is regenerated before pasting.
+  *
+  * @param markers Object that maps marker name to corresponding range.
+  * @param getPastedDocumentElement Getter used to get target markers element.
+  * @internal
+  */
+  _pasteMarkersIntoTransformedElement(e, t) {
+    const n = this._getPasteMarkersFromRangeMap(e);
+    return this.editor.model.change((r) => {
+      const i = this._insertFakeMarkersElements(r, n), s = t(r), o = this._removeFakeMarkersInsideElement(r, s);
+      for (const l of Object.values(i).flat()) r.remove(l);
+      for (const [l, d] of Object.entries(o)) r.model.markers.has(l) || r.addMarker(l, {
+        usingOperation: !0,
+        affectsData: !0,
+        range: d
+      });
+      return s;
+    });
+  }
+  /**
+  * Pastes document fragment with markers to document.
+  * If `duplicateOnPaste` is `true` in marker config then associated markers IDs
+  * are regenerated before pasting to avoid markers duplications in content.
+  *
+  * @param fragment Document fragment that should contain already processed by pipeline markers.
+  * @internal
+  */
+  _pasteFragmentWithMarkers(e) {
+    const t = this._getPasteMarkersFromRangeMap(e.markers);
+    e.markers.clear();
+    for (const n of t) e.markers.set(n.name, n.range);
+    return this.editor.model.insertContent(e);
+  }
+  /**
+  * In some situations we have to perform copy on selected fragment with certain markers. This function allows to temporarily bypass
+  * restrictions on markers that we want to copy.
+  *
+  * This function executes `executor()` callback. For the duration of the callback, if the clipboard pipeline is used to copy
+  * content, markers with the specified name will be copied to the clipboard as well.
+  *
+  * @param markerName Which markers should be copied.
+  * @param executor Callback executed.
+  * @param config Optional configuration flags used to copy (such like partial copy flag).
+  * @internal
+  */
+  _forceMarkersCopy(e, t, n = {
+    allowedActions: "all",
+    copyPartiallySelected: !0,
+    duplicateOnPaste: !0
+  }) {
+    const r = this._markersToCopy.get(e);
+    this._markersToCopy.set(e, n), t(), r ? this._markersToCopy.set(e, r) : this._markersToCopy.delete(e);
+  }
+  /**
+  * Checks if marker can be copied.
+  *
+  * @param markerName Name of checked marker.
+  * @param action Type of clipboard action. If null then checks only if marker is registered as copyable.
+  * @internal
+  */
+  _isMarkerCopyable(e, t) {
+    const n = this._getMarkerClipboardConfig(e);
+    if (!n) return !1;
+    if (!t) return !0;
+    const { allowedActions: r } = n;
+    return r === "all" || r.includes(t);
+  }
+  /**
+  * Checks if marker has any clipboard copy behavior configuration.
+  *
+  * @param markerName Name of checked marker.
+  */
+  _hasMarkerConfiguration(e) {
+    return !!this._getMarkerClipboardConfig(e);
+  }
+  /**
+  * Returns marker's configuration flags passed during registration.
+  *
+  * @param markerName Name of marker that should be returned.
+  * @internal
+  */
+  _getMarkerClipboardConfig(e) {
+    const [t] = e.split(":");
+    return this._markersToCopy.get(t) || null;
+  }
+  /**
+  * First step of copying markers. It looks for markers intersecting with given selection and inserts `$marker` elements
+  * at positions where document markers start or end. This way `$marker` elements can be easily copied together with
+  * the rest of the content of the selection.
+  *
+  * @param writer An instance of the model writer.
+  * @param selection Selection to be checked.
+  * @param action Type of clipboard action.
+  */
+  _insertFakeMarkersIntoSelection(e, t, n) {
+    const r = this._getCopyableMarkersFromSelection(e, t, n);
+    return this._insertFakeMarkersElements(e, r);
+  }
+  /**
+  * Returns array of markers that can be copied in specified selection.
+  *
+  * If marker cannot be copied partially (according to `copyPartiallySelected` configuration flag) and
+  * is not present entirely in any selection range then it will be skipped.
+  *
+  * @param writer An instance of the model writer.
+  * @param selection  Selection which will be checked.
+  * @param action Type of clipboard action. If null then checks only if marker is registered as copyable.
+  */
+  _getCopyableMarkersFromSelection(e, t, n) {
+    const r = Array.from(t.getRanges()), i = new Set(r.flatMap((o) => Array.from(e.model.markers.getMarkersIntersectingRange(o)))), s = (o) => {
+      if (!this._isMarkerCopyable(o.name, n)) return !1;
+      const { copyPartiallySelected: l } = this._getMarkerClipboardConfig(o.name);
+      if (!l) {
+        const d = o.getRange();
+        return r.some((c) => c.containsRange(d, !0));
+      }
+      return !0;
+    };
+    return Array.from(i).filter(s).map((o) => ({
+      name: n === "dragstart" ? this._getUniqueMarkerName(o.name) : o.name,
+      range: o.getRange()
+    }));
+  }
+  /**
+  * Picks all markers from markers map that can be pasted.
+  * If `duplicateOnPaste` is `true`, it regenerates their IDs to ensure uniqueness.
+  * If marker is not registered, it will be kept in the array anyway.
+  *
+  * @param markers Object that maps marker name to corresponding range.
+  * @param action Type of clipboard action. If null then checks only if marker is registered as copyable.
+  */
+  _getPasteMarkersFromRangeMap(e, t = null) {
+    const { model: n } = this.editor;
+    return (e instanceof Map ? Array.from(e.entries()) : Object.entries(e)).flatMap(([r, i]) => {
+      if (!this._hasMarkerConfiguration(r)) return [{
+        name: r,
+        range: i
+      }];
+      if (this._isMarkerCopyable(r, t)) {
+        const s = this._getMarkerClipboardConfig(r), o = n.markers.has(r) && n.markers.get(r).getRange().root.rootName === "$graveyard";
+        return (s.duplicateOnPaste || o) && (r = this._getUniqueMarkerName(r)), [{
+          name: r,
+          range: i
+        }];
+      }
+      return [];
+    });
+  }
+  /**
+  * Inserts specified array of fake markers elements to document and assigns them `type` and `name` attributes.
+  * Fake markers elements are used to calculate position of markers on pasted fragment that were transformed during
+  * steps between copy and paste.
+  *
+  * @param writer An instance of the model writer.
+  * @param markers Array of markers that will be inserted.
+  */
+  _insertFakeMarkersElements(e, t) {
+    const n = {}, r = t.flatMap((i) => {
+      const { start: s, end: o } = i.range;
+      return [{
+        position: s,
+        marker: i,
+        type: "start"
+      }, {
+        position: o,
+        marker: i,
+        type: "end"
+      }];
+    }).sort(({ position: i }, { position: s }) => i.isBefore(s) ? 1 : -1);
+    for (const { position: i, marker: s, type: o } of r) {
+      const l = e.createElement("$marker", {
+        "data-name": s.name,
+        "data-type": o
+      });
+      n[s.name] || (n[s.name] = []), n[s.name].push(l), e.insert(l, i);
+    }
+    return n;
+  }
+  /**
+  * Removes all `$marker` elements from the given document fragment.
+  *
+  * Returns an object where keys are marker names, and values are ranges corresponding to positions
+  * where `$marker` elements were inserted.
+  *
+  * If the document fragment had only one `$marker` element for given marker (start or end) the other boundary is set automatically
+  * (to the end or start of the document fragment, respectively).
+  *
+  * @param writer An instance of the model writer.
+  * @param rootElement The element to be checked.
+  */
+  _removeFakeMarkersInsideElement(e, t) {
+    const n = this._getAllFakeMarkersFromElement(e, t).reduce((r, i) => {
+      const s = i.markerElement && e.createPositionBefore(i.markerElement);
+      let o = r[i.name], l = !1;
+      return o != null && o.start && (o != null && o.end) && (this._getMarkerClipboardConfig(i.name).duplicateOnPaste ? r[this._getUniqueMarkerName(i.name)] = r[i.name] : l = !0, o = null), l || (r[i.name] = {
+        ...o,
+        [i.type]: s
+      }), i.markerElement && e.remove(i.markerElement), r;
+    }, {});
+    return ce(n, (r) => new de(r.start || e.createPositionFromPath(t, [0]), r.end || e.createPositionAt(t, "end")));
+  }
+  /**
+  * Returns array that contains list of fake markers with corresponding `$marker` elements.
+  *
+  * For each marker, there can be two `$marker` elements or only one (if the document fragment contained
+  * only the beginning or only the end of a marker).
+  *
+  * @param writer An instance of the model writer.
+  * @param rootElement The element to be checked.
+  */
+  _getAllFakeMarkersFromElement(e, t) {
+    const n = Array.from(e.createRangeIn(t)).flatMap(({ item: s }) => s.is("element", "$marker") ? [{
+      markerElement: s,
+      name: s.getAttribute("data-name"),
+      type: s.getAttribute("data-type")
+    }] : []), r = [], i = [];
+    for (const s of n)
+      s.type === "end" && (n.some((o) => o.name === s.name && o.type === "start") || r.push({
+        markerElement: null,
+        name: s.name,
+        type: "start"
+      })), s.type === "start" && (n.some((o) => o.name === s.name && o.type === "end") || i.unshift({
+        markerElement: null,
+        name: s.name,
+        type: "end"
+      }));
+    return [
+      ...r,
+      ...n,
+      ...i
+    ];
+  }
+  /**
+  * When copy of markers occurs we have to make sure that pasted markers have different names
+  * than source markers. This functions helps with assigning unique part to marker name to
+  * prevent duplicated markers error.
+  *
+  * @param name Name of marker
+  */
+  _getUniqueMarkerName(e) {
+    const t = e.split(":"), n = q().substring(1, 6);
+    return t.length === 3 ? `${t.slice(0, 2).join(":")}:${n}` : `${t.join(":")}:${n}`;
+  }
+};
+/**
+* @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 D = class extends b {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ClipboardPipeline";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [Y];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    this.editor.editing.view.addObserver(v), this._setupPasteDrop(), this._setupCopyCut();
+  }
+  /**
+  * Fires Clipboard `'outputTransformation'` event for given parameters.
+  *
+  * @internal
+  */
+  _fireOutputTransformationEvent(a, e, t) {
+    const n = this.editor.plugins.get("ClipboardMarkersUtils");
+    this.editor.model.enqueueChange({ isUndoable: t === "cut" }, () => {
+      const r = n._copySelectedFragmentWithMarkers(t, e);
+      this.fire("outputTransformation", {
+        dataTransfer: a,
+        content: r,
+        method: t
+      });
+    });
+  }
+  /**
+  * The clipboard paste pipeline.
+  */
+  _setupPasteDrop() {
+    const a = this.editor, e = a.model, t = a.editing.view, n = t.document, r = this.editor.plugins.get("ClipboardMarkersUtils");
+    this.listenTo(n, "clipboardInput", (i, s) => {
+      s.method == "paste" && !a.model.canEditAt(a.model.document.selection) && i.stop();
+    }, { priority: "highest" }), this.listenTo(n, "clipboardInput", (i, s) => {
+      const o = s.dataTransfer, l = new j(this, "inputTransformation"), d = o.getData("application/ckeditor5-editor-id") || null, c = typeof s.content == "string" ? this.editor.data.htmlProcessor.toView(ue(s.content)) : s.content;
+      this.fire(l, {
+        content: c,
+        dataTransfer: o,
+        sourceEditorId: d,
+        extraContent: s.extraContent,
+        targetRanges: s.targetRanges,
+        method: s.method
+      }), l.stop.called && i.stop(), t.scrollToTheSelection();
+    }, { priority: "low" }), this.listenTo(this, "inputTransformation", (i, s) => {
+      if (s.content.isEmpty) return;
+      const o = this.editor.data.toModel(s.content, "$clipboardHolder");
+      o.childCount != 0 && (i.stop(), e.change(() => {
+        this.fire("contentInsertion", {
+          content: o,
+          method: s.method,
+          sourceEditorId: s.sourceEditorId,
+          dataTransfer: s.dataTransfer,
+          targetRanges: s.targetRanges
+        });
+      }));
+    }, { priority: "low" }), this.listenTo(this, "contentInsertion", (i, s) => {
+      s.resultRange = r._pasteFragmentWithMarkers(s.content);
+    }, { priority: "low" });
+  }
+  /**
+  * The clipboard copy/cut pipeline.
+  */
+  _setupCopyCut() {
+    const a = this.editor, e = a.model.document, t = a.editing.view.document, n = (r, i) => {
+      const s = i.dataTransfer;
+      i.preventDefault(), this._fireOutputTransformationEvent(s, e.selection, r.name);
+    };
+    this.listenTo(t, "copy", n, { priority: "low" }), this.listenTo(t, "cut", (r, i) => {
+      a.model.canEditAt(a.model.document.selection) ? n(r, i) : i.preventDefault();
+    }, { priority: "low" }), this.listenTo(this, "outputTransformation", (r, i) => {
+      const s = a.data.toView(i.content, { isClipboardPipeline: !0 });
+      t.fire("clipboardOutput", {
+        dataTransfer: i.dataTransfer,
+        content: s,
+        method: i.method
+      });
+    }, { priority: "low" }), this.listenTo(t, "clipboardOutput", (r, i) => {
+      i.content.isEmpty || (i.dataTransfer.setData("text/html", this.editor.data.htmlProcessor.toData(i.content)), i.dataTransfer.setData("text/plain", G(a.data.htmlProcessor.domConverter, i.content)), i.dataTransfer.setData("application/ckeditor5-editor-id", this.editor.id)), i.method == "cut" && a.model.deleteContent(e.selection);
+    }, { priority: "low" });
+  }
+};
+/**
+* @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
+*/
+/* istanbul ignore file -- @preserve */
+const P = /* @__PURE__ */ oe("px");
+var fe = class extends pe {
+  /**
+  * @inheritDoc
+  */
+  constructor() {
+    super();
+    const a = this.bindTemplate;
+    this.set({
+      isVisible: !1,
+      left: null,
+      top: null,
+      width: null
+    }), this.setTemplate({
+      tag: "div",
+      attributes: {
+        class: [
+          "ck",
+          "ck-clipboard-drop-target-line",
+          a.if("isVisible", "ck-hidden", (e) => !e)
+        ],
+        style: {
+          left: a.to("left", (e) => P(e)),
+          top: a.to("top", (e) => P(e)),
+          width: a.to("width", (e) => P(e))
+        }
+      }
+    });
+  }
+};
+/**
+* @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 C = class extends b {
+  constructor() {
+    super(...arguments);
+    /**
+    * A delayed callback removing the drop marker.
+    *
+    * @internal
+    */
+    g(this, "removeDropMarkerDelayed", H(() => this.removeDropMarker(), 40));
+    /**
+    * A throttled callback updating the drop marker.
+    */
+    g(this, "_updateDropMarkerThrottled", B((e) => this._updateDropMarker(e), 40));
+    /**
+    * A throttled callback reconverting the drop parker.
+    */
+    g(this, "_reconvertMarkerThrottled", B(() => {
+      this.editor.model.markers.has("drop-target") && this.editor.editing.reconvertMarker("drop-target");
+    }, 0));
+    /**
+    * The horizontal drop target line view.
+    */
+    g(this, "_dropTargetLineView", new fe());
+    /**
+    * DOM Emitter.
+    */
+    g(this, "_domEmitter", new (A())());
+    /**
+    * Map of document scrollable elements.
+    */
+    g(this, "_scrollables", /* @__PURE__ */ new Map());
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "DragDropTarget";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    this._setupDropMarker();
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    this._domEmitter.stopListening();
+    for (const { resizeObserver: e } of this._scrollables.values()) e.destroy();
+    return this._updateDropMarkerThrottled.cancel(), this.removeDropMarkerDelayed.cancel(), this._reconvertMarkerThrottled.cancel(), super.destroy();
+  }
+  /**
+  * Finds the drop target range and updates the drop marker.
+  *
+  * @return The updated drop target range or null if no valid range was found.
+  * @internal
+  */
+  updateDropMarker(e, t, n, r, i, s) {
+    this.removeDropMarkerDelayed.cancel();
+    const o = $(this.editor, e, t, n, r, i, s);
+    /* istanbul ignore next -- @preserve */
+    return o ? s && s.containsRange(o) ? (this.removeDropMarker(), null) : o && !this.editor.model.canEditAt(o) ? (this.removeDropMarker(), null) : (this._updateDropMarkerThrottled(o), o) : null;
+  }
+  /**
+  * Finds the final drop target range.
+  *
+  * @internal
+  */
+  getFinalDropRange(e, t, n, r, i, s) {
+    const o = $(this.editor, e, t, n, r, i, s);
+    return this.removeDropMarker(), o;
+  }
+  /**
+  * Removes the drop target marker.
+  *
+  * @internal
+  */
+  removeDropMarker() {
+    const e = this.editor.model;
+    this.removeDropMarkerDelayed.cancel(), this._updateDropMarkerThrottled.cancel(), this._dropTargetLineView.isVisible = !1, e.markers.has("drop-target") && e.change((t) => {
+      t.removeMarker("drop-target");
+    });
+  }
+  /**
+  * Creates downcast conversion for the drop target marker.
+  */
+  _setupDropMarker() {
+    const e = this.editor;
+    e.ui.view.body.add(this._dropTargetLineView), e.conversion.for("editingDowncast").markerToHighlight({
+      model: "drop-target",
+      view: { classes: ["ck-clipboard-drop-target-range"] }
+    }), e.conversion.for("editingDowncast").markerToElement({
+      model: "drop-target",
+      view: (t, { writer: n }) => {
+        if (e.model.schema.checkChild(t.markerRange.start, "$text"))
+          return this._dropTargetLineView.isVisible = !1, this._createDropTargetPosition(n);
+        t.markerRange.isCollapsed ? this._updateDropTargetLine(t.markerRange) : this._dropTargetLineView.isVisible = !1;
+      }
+    });
+  }
+  /**
+  * Updates the drop target marker to the provided range.
+  *
+  * @param targetRange The range to set the marker to.
+  */
+  _updateDropMarker(e) {
+    const t = this.editor, n = t.model.markers;
+    t.model.change((r) => {
+      n.has("drop-target") ? n.get("drop-target").getRange().isEqual(e) || r.updateMarker("drop-target", { range: e }) : r.addMarker("drop-target", {
+        range: e,
+        usingOperation: !1,
+        affectsData: !1
+      });
+    });
+  }
+  /**
+  * Creates the UI element for vertical (in-line) drop target.
+  */
+  _createDropTargetPosition(e) {
+    return e.createUIElement("span", { class: "ck ck-clipboard-drop-target-position" }, function(t) {
+      const n = this.toDomElement(t);
+      return n.append("⁠", t.createElement("span"), "⁠"), n;
+    });
+  }
+  /**
+  * Updates the horizontal drop target line.
+  */
+  _updateDropTargetLine(e) {
+    const t = this.editor.editing, n = e.start.nodeBefore, r = e.start.nodeAfter, i = e.start.parent, s = n ? t.mapper.toViewElement(n) : null, o = s ? t.view.domConverter.mapViewToDom(s) : null, l = r ? t.mapper.toViewElement(r) : null, d = l ? t.view.domConverter.mapViewToDom(l) : null, c = t.mapper.toViewElement(i);
+    if (!c) return;
+    const p = t.view.domConverter.mapViewToDom(c), m = this._getScrollableRect(c), { scrollX: u, scrollY: y } = h.window, x = o ? new _(o) : null, S = d ? new _(d) : null, T = new _(p).excludeScrollbarsAndBorders(), O = x ? x.bottom : T.top, M = S ? S.top : T.bottom, I = h.window.getComputedStyle(p), R = O <= M ? (O + M) / 2 : M;
+    if (m.top < R && R < m.bottom) {
+      const Q = T.left + parseFloat(I.paddingLeft), Z = T.right - parseFloat(I.paddingRight), F = Math.max(Q + u, m.left), ee = Math.min(Z + u, m.right);
+      this._dropTargetLineView.set({
+        isVisible: !0,
+        left: F,
+        top: R + y,
+        width: ee - F
+      });
+    } else this._dropTargetLineView.isVisible = !1;
+  }
+  /**
+  * Finds the closest scrollable element rect for the given view element.
+  */
+  _getScrollableRect(e) {
+    const t = e.root.rootName;
+    let n;
+    if (this._scrollables.has(t)) n = this._scrollables.get(t).domElement;
+    else {
+      n = _e(this.editor.editing.view.domConverter.mapViewToDom(e)), this._domEmitter.listenTo(n, "scroll", this._reconvertMarkerThrottled, { usePassive: !0 });
+      const r = new ie(n, this._reconvertMarkerThrottled);
+      this._scrollables.set(t, {
+        domElement: n,
+        resizeObserver: r
+      });
+    }
+    return new _(n).excludeScrollbarsAndBorders();
+  }
+};
+function $(a, e, t, n, r, i, s) {
+  const o = a.model, l = a.editing.mapper;
+  let d = N(a, e);
+  for (; d; ) {
+    if (!i) {
+      if (o.schema.checkChild(d, "$text")) {
+        if (t) {
+          const c = t[0].start, p = l.toModelPosition(c);
+          if (!s || Array.from(s.getItems({ shallow: !0 })).some((m) => o.schema.checkChild(p, m))) {
+            if (o.schema.checkChild(p, "$text")) return o.createRange(p);
+            if (c) return w(a, N(a, c.parent), n, r);
+          }
+        }
+      } else if (o.schema.isInline(d)) return w(a, d, n, r);
+    }
+    if (o.schema.isBlock(d)) return w(a, d, n, r);
+    if (o.schema.checkChild(d, "$block")) {
+      const c = Array.from(d.getChildren()).filter((u) => u.is("element") && !be(a, u));
+      let p = 0, m = c.length;
+      if (m == 0) return o.createRange(o.createPositionAt(d, "end"));
+      for (; p < m - 1; ) {
+        const u = Math.floor((p + m) / 2);
+        K(a, c[u], n, r) == "before" ? m = u : p = u;
+      }
+      return w(a, c[p], n, r);
+    }
+    d = d.parent;
+  }
+  return null;
+}
+function be(a, e) {
+  const t = a.editing.mapper, n = a.editing.view.domConverter, r = t.toViewElement(e);
+  if (!r) return !0;
+  const i = n.mapViewToDom(r);
+  return h.window.getComputedStyle(i).float != "none";
+}
+function w(a, e, t, n) {
+  const r = a.model;
+  return r.createRange(r.createPositionAt(e, K(a, e, t, n)));
+}
+function K(a, e, t, n) {
+  const r = a.editing.mapper, i = a.editing.view.domConverter, s = r.toViewElement(e), o = i.mapViewToDom(s), l = new _(o);
+  return a.model.schema.isInline(e) ? t < (l.left + l.right) / 2 ? "before" : "after" : n < (l.top + l.bottom) / 2 ? "before" : "after";
+}
+function N(a, e) {
+  const t = a.editing.mapper, n = a.editing.view, r = t.toModelElement(e);
+  if (r) return r;
+  const i = n.createPositionBefore(e), s = t.findMappedViewAncestor(i);
+  return t.toModelElement(s);
+}
+function _e(a) {
+  let e = a;
+  do {
+    e = e.parentElement;
+    const t = h.window.getComputedStyle(e).overflowY;
+    if (t == "auto" || t == "scroll") break;
+  } while (e.tagName != "BODY");
+  return e;
+}
+/**
+* @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 ke = class extends b {
+  constructor() {
+    super(...arguments);
+    /**
+    * Whether current dragging is started by block toolbar button dragging.
+    */
+    g(this, "_isBlockDragging", !1);
+    /**
+    * DOM Emitter.
+    */
+    g(this, "_domEmitter", new (A())());
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "DragDropBlockToolbar";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor;
+    if (this.listenTo(e, "change:isReadOnly", (t, n, r) => {
+      r ? (this.forceDisabled("readOnlyMode"), this._isBlockDragging = !1) : this.clearForceDisabled("readOnlyMode");
+    }), f.isAndroid && this.forceDisabled("noAndroidSupport"), e.plugins.has("BlockToolbar")) {
+      const t = e.plugins.get("BlockToolbar").buttonView.element;
+      this._domEmitter.listenTo(t, "dragstart", (n, r) => this._handleBlockDragStart(r)), this._domEmitter.listenTo(h.document, "dragover", (n, r) => this._handleBlockDragging(r)), this._domEmitter.listenTo(h.document, "drop", (n, r) => this._handleBlockDragging(r)), this._domEmitter.listenTo(h.document, "dragend", () => this._handleBlockDragEnd(), { useCapture: !0 }), this.isEnabled && t.setAttribute("draggable", "true"), this.on("change:isEnabled", (n, r, i) => {
+        t.setAttribute("draggable", i ? "true" : "false");
+      });
+    }
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    return this._domEmitter.stopListening(), super.destroy();
+  }
+  /**
+  * The `dragstart` event handler.
+  */
+  _handleBlockDragStart(e) {
+    if (!this.isEnabled) return;
+    const t = this.editor.model, n = t.document.selection, r = this.editor.editing.view, i = Array.from(n.getSelectedBlocks()), s = t.createRange(t.createPositionBefore(i[0]), t.createPositionAfter(i[i.length - 1]));
+    t.change((o) => o.setSelection(s)), this._isBlockDragging = !0, r.focus(), r.getObserver(v).onDomEvent(e);
+  }
+  /**
+  * The `dragover` and `drop` event handler.
+  */
+  _handleBlockDragging(e) {
+    if (!this.isEnabled || !this._isBlockDragging) return;
+    const t = e.clientX + (this.editor.locale.contentLanguageDirection == "ltr" ? 100 : -100), n = e.clientY, r = document.elementFromPoint(t, n), i = this.editor.editing.view;
+    !r || !r.closest(".ck-editor__editable") || i.getObserver(v).onDomEvent({
+      ...e,
+      type: e.type,
+      dataTransfer: e.dataTransfer,
+      target: r,
+      clientX: t,
+      clientY: n,
+      preventDefault: () => e.preventDefault(),
+      stopPropagation: () => e.stopPropagation()
+    });
+  }
+  /**
+  * The `dragend` event handler.
+  */
+  _handleBlockDragEnd() {
+    this._isBlockDragging = !1;
+  }
+};
+/**
+* @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 ve = class extends b {
+  constructor() {
+    super(...arguments);
+    /**
+    * The live range over the original content that is being dragged.
+    */
+    g(this, "_draggedRange");
+    /**
+    * The UID of current dragging that is used to verify if the drop started in the same editor as the drag start.
+    *
+    * **Note**: This is a workaround for broken 'dragend' events (they are not fired if the source text node got removed).
+    */
+    g(this, "_draggingUid");
+    /**
+    * The reference to the model element that currently has a `draggable` attribute set (it is set while dragging).
+    */
+    g(this, "_draggableElement");
+    /**
+    * A delayed callback removing draggable attributes.
+    */
+    g(this, "_clearDraggableAttributesDelayed", H(() => this._clearDraggableAttributes(), 40));
+    /**
+    * Whether the dragged content can be dropped only in block context.
+    */
+    g(this, "_blockMode", !1);
+    /**
+    * DOM Emitter.
+    */
+    g(this, "_domEmitter", new (A())());
+    /**
+    * The DOM element used to generate dragged preview image.
+    */
+    g(this, "_previewContainer");
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "DragDrop";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [
+      D,
+      ge,
+      C,
+      ke
+    ];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.editing.view;
+    this._draggedRange = null, this._draggingUid = "", this._draggableElement = null, t.addObserver(v), t.addObserver(se), this._setupDragging(), this._setupContentInsertionIntegration(), this._setupClipboardInputIntegration(), this._setupDraggableAttributeHandling(), this.listenTo(e, "change:isReadOnly", (n, r, i) => {
+      i ? this.forceDisabled("readOnlyMode") : this.clearForceDisabled("readOnlyMode");
+    }), this.on("change:isEnabled", (n, r, i) => {
+      i || this._finalizeDragging(!1);
+    }), f.isAndroid && this.forceDisabled("noAndroidSupport");
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    return this._draggedRange && (this._draggedRange.detach(), this._draggedRange = null), this._previewContainer && this._previewContainer.remove(), this._domEmitter.stopListening(), this._clearDraggableAttributesDelayed.cancel(), super.destroy();
+  }
+  /**
+  * Drag and drop events handling.
+  */
+  _setupDragging() {
+    const e = this.editor, t = e.model, n = e.editing.view, r = n.document, i = e.plugins.get(C);
+    this.listenTo(r, "dragstart", (s, o) => {
+      var y;
+      if ((y = o.target) != null && y.is("editableElement")) {
+        o.preventDefault();
+        return;
+      }
+      if (this._prepareDraggedRange(o.target), !this._draggedRange) {
+        o.preventDefault();
+        return;
+      }
+      this._draggingUid = q();
+      const l = this.isEnabled && e.model.canEditAt(this._draggedRange);
+      o.dataTransfer.effectAllowed = l ? "copyMove" : "copy", o.dataTransfer.setData("application/ckeditor5-dragging-uid", this._draggingUid);
+      const d = t.createSelection(this._draggedRange.toRange());
+      this.editor.plugins.get("ClipboardPipeline")._fireOutputTransformationEvent(o.dataTransfer, d, "dragstart");
+      const { dataTransfer: c, domTarget: p, domEvent: m } = o, { clientX: u } = m;
+      this._updatePreview({
+        dataTransfer: c,
+        domTarget: p,
+        clientX: u
+      }), o.stopPropagation(), l || (this._draggedRange.detach(), this._draggedRange = null, this._draggingUid = "");
+    }, { priority: "low" }), this.listenTo(r, "dragend", (s, o) => {
+      this._finalizeDragging(!o.dataTransfer.isCanceled && o.dataTransfer.dropEffect == "move");
+    }, { priority: "low" }), this._domEmitter.listenTo(h.document, "dragend", () => {
+      this._blockMode = !1;
+    }, { useCapture: !0 }), this.listenTo(r, "dragenter", () => {
+      this.isEnabled && n.focus();
+    }), this.listenTo(r, "dragleave", () => {
+      i.removeDropMarkerDelayed();
+    }), this.listenTo(r, "dragging", (s, o) => {
+      if (!this.isEnabled) {
+        o.dataTransfer.dropEffect = "none";
+        return;
+      }
+      const { clientX: l, clientY: d } = o.domEvent;
+      if (!i.updateDropMarker(o.target, o.targetRanges, l, d, this._blockMode, this._draggedRange)) {
+        o.dataTransfer.dropEffect = "none";
+        return;
+      }
+      this._draggedRange || (o.dataTransfer.dropEffect = "copy"), f.isGecko || (o.dataTransfer.effectAllowed == "copy" ? o.dataTransfer.dropEffect = "copy" : ["all", "copyMove"].includes(o.dataTransfer.effectAllowed) && (o.dataTransfer.dropEffect = "move")), s.stop();
+    }, { priority: "low" });
+  }
+  /**
+  * Integration with the `clipboardInput` event.
+  */
+  _setupClipboardInputIntegration() {
+    const e = this.editor, t = e.editing.view.document, n = e.plugins.get(C);
+    this.listenTo(t, "clipboardInput", (r, i) => {
+      if (i.method != "drop") return;
+      const { clientX: s, clientY: o } = i.domEvent, l = n.getFinalDropRange(i.target, i.targetRanges, s, o, this._blockMode, this._draggedRange);
+      if (!l) {
+        this._finalizeDragging(!1), r.stop();
+        return;
+      }
+      if (this._draggedRange && this._draggingUid != i.dataTransfer.getData("application/ckeditor5-dragging-uid") && (this._draggedRange.detach(), this._draggedRange = null, this._draggingUid = ""), W(i.dataTransfer) == "move" && this._draggedRange && this._draggedRange.containsRange(l, !0)) {
+        this._finalizeDragging(!1), r.stop();
+        return;
+      }
+      i.targetRanges = [e.editing.mapper.toViewRange(l)];
+    }, { priority: "high" });
+  }
+  /**
+  * Integration with the `contentInsertion` event of the clipboard pipeline.
+  */
+  _setupContentInsertionIntegration() {
+    const e = this.editor.plugins.get(D);
+    e.on("contentInsertion", (t, n) => {
+      if (!this.isEnabled || n.method !== "drop") return;
+      const r = n.targetRanges.map((i) => this.editor.editing.mapper.toModelRange(i));
+      this.editor.model.change((i) => i.setSelection(r));
+    }, { priority: "high" }), e.on("contentInsertion", (t, n) => {
+      if (!this.isEnabled || n.method !== "drop") return;
+      const r = W(n.dataTransfer) == "move", i = !n.resultRange || !n.resultRange.isCollapsed;
+      this._finalizeDragging(i && r);
+    }, { priority: "lowest" });
+  }
+  /**
+  * Adds listeners that add the `draggable` attribute to the elements while the mouse button is down so the dragging could start.
+  */
+  _setupDraggableAttributeHandling() {
+    const e = this.editor, t = e.editing.view, n = t.document;
+    this.listenTo(n, "pointerdown", (r, i) => {
+      if (f.isAndroid || !i) return;
+      this._clearDraggableAttributesDelayed.cancel();
+      let s = z(i.target);
+      if (f.isBlink && !e.isReadOnly && !s && !n.selection.isCollapsed) {
+        const o = n.selection.getSelectedElement();
+        (!o || !k(o)) && (s = n.selection.editableElement);
+      }
+      s && (t.change((o) => {
+        o.setAttribute("draggable", "true", s);
+      }), this._draggableElement = e.editing.mapper.toModelElement(s));
+    }), this.listenTo(n, "pointerup", () => {
+      f.isAndroid || this._clearDraggableAttributesDelayed();
+    });
+  }
+  /**
+  * Removes the `draggable` attribute from the element that was used for dragging.
+  */
+  _clearDraggableAttributes() {
+    const e = this.editor.editing;
+    e.view.change((t) => {
+      this._draggableElement && this._draggableElement.root.rootName != "$graveyard" && t.removeAttribute("draggable", e.mapper.toViewElement(this._draggableElement)), this._draggableElement = null;
+    });
+  }
+  /**
+  * Deletes the dragged content from its original range and clears the dragging state.
+  *
+  * @param moved Whether the move succeeded.
+  */
+  _finalizeDragging(e) {
+    const t = this.editor, n = t.model;
+    t.plugins.get(C).removeDropMarker(), this._clearDraggableAttributes(), t.plugins.has("WidgetToolbarRepository") && t.plugins.get("WidgetToolbarRepository").clearForceDisabled("dragDrop"), this._draggingUid = "", this._previewContainer && (this._previewContainer.remove(), this._previewContainer = void 0), this._draggedRange && (e && this.isEnabled && n.change((r) => {
+      const i = n.createSelection(this._draggedRange);
+      n.deleteContent(i, { doNotAutoparagraph: !0 });
+      const s = i.getFirstPosition().parent;
+      s.isEmpty && !n.schema.checkChild(s, "$text") && n.schema.checkChild(s, "paragraph") && r.insertElement("paragraph", s, 0);
+    }), this._draggedRange.detach(), this._draggedRange = null);
+  }
+  /**
+  * Sets the dragged source range based on event target and document selection.
+  */
+  _prepareDraggedRange(e) {
+    const t = this.editor, n = t.model, r = n.document.selection, i = e ? z(e) : null;
+    if (i) {
+      const d = t.editing.mapper.toModelElement(i);
+      this._draggedRange = E.fromRange(n.createRangeOn(d)), this._blockMode = n.schema.isBlock(d), t.plugins.has("WidgetToolbarRepository") && t.plugins.get("WidgetToolbarRepository").forceDisabled("dragDrop");
+      return;
+    }
+    if (r.isCollapsed && !r.getFirstPosition().parent.isEmpty) return;
+    const s = Array.from(r.getSelectedBlocks()), o = r.getFirstRange();
+    if (s.length == 0) {
+      this._draggedRange = E.fromRange(o);
+      return;
+    }
+    const l = J(n, s);
+    if (s.length > 1)
+      this._draggedRange = E.fromRange(l), this._blockMode = !0;
+    else if (s.length == 1) {
+      const d = o.start.isTouching(l.start) && o.end.isTouching(l.end);
+      this._draggedRange = E.fromRange(d ? l : o), this._blockMode = d;
+    }
+    n.change((d) => d.setSelection(this._draggedRange.toRange()));
+  }
+  /**
+  * Updates the dragged preview image.
+  */
+  _updatePreview({ dataTransfer: e, domTarget: t, clientX: n }) {
+    const r = this.editor.editing.view, i = r.document.selection.editableElement, s = r.domConverter.mapViewToDom(i), o = h.window.getComputedStyle(s);
+    this._previewContainer ? this._previewContainer.firstElementChild && this._previewContainer.removeChild(this._previewContainer.firstElementChild) : (this._previewContainer = V(h.document, "div", { style: "position: fixed; left: -999999px;" }), h.document.body.appendChild(this._previewContainer));
+    const l = V(h.document, "div");
+    l.className = "ck ck-content ck-clipboard-preview";
+    const d = new _(s), c = parseFloat(o.paddingLeft), p = parseFloat(o.paddingRight), m = parseFloat(o.width) - c - p;
+    if (s.contains(t)) if (f.isiOS)
+      l.style.maxWidth = `${m}px`, l.style.padding = "10px", l.style.minWidth = "200px", l.style.minHeight = "20px", l.style.boxSizing = "border-box", l.style.backgroundColor = "var(--ck-color-base-background)";
+    else return;
+    else if (f.isiOS)
+      l.style.width = `${m}px`, l.style.backgroundColor = "var(--ck-color-base-background)";
+    else {
+      const u = d.left - n + c;
+      l.style.width = `${m + u}px`, l.style.paddingLeft = `${u}px`;
+    }
+    r.domConverter.setContentOf(l, e.getData("text/html")), e.setDragImage(l, 0, 0), this._previewContainer.appendChild(l);
+  }
+};
+function W(a) {
+  return f.isGecko ? a.dropEffect : ["all", "copyMove"].includes(a.effectAllowed) ? "move" : "copy";
+}
+function z(a) {
+  if (a.is("editableElement")) return null;
+  if (a.hasClass("ck-widget__selection-handle")) return a.findAncestor(k);
+  if (k(a)) return a;
+  const e = a.findAncestor((t) => k(t) || t.is("editableElement"));
+  return k(e) ? e : null;
+}
+function J(a, e) {
+  const t = e[0], n = e[e.length - 1], r = t.getCommonAncestor(n), i = a.createPositionBefore(t), s = a.createPositionAfter(n);
+  if (r && r.is("element") && !a.schema.isLimit(r)) {
+    const o = a.createRangeOn(r), l = i.isTouching(o.start), d = s.isTouching(o.end);
+    if (l && d) return J(a, [r]);
+  }
+  return a.createRange(i, s);
+}
+/**
+* @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 De = class extends b {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "PastePlainText";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [D];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const a = this.editor, e = a.model, t = a.editing.view, n = e.document.selection;
+    t.addObserver(v), a.plugins.get(D).on("contentInsertion", (r, i) => {
+      ye(i.content, e) && e.change((s) => {
+        const o = Array.from(n.getAttributes()).filter(([d]) => e.schema.getAttributeProperties(d).isFormatting);
+        n.isCollapsed || e.deleteContent(n, { doNotAutoparagraph: !0 }), o.push(...n.getAttributes());
+        const l = s.createRangeIn(i.content);
+        for (const d of l.getItems()) for (const c of o) e.schema.checkAttribute(d, c[0]) && s.setAttribute(c[0], c[1], d);
+      });
+    });
+  }
+};
+function ye(a, e) {
+  let t = e.createRangeIn(a);
+  if (a.childCount == 1) {
+    const n = a.getChild(0);
+    n.is("element") && e.schema.isBlock(n) && !e.schema.isObject(n) && !e.schema.isLimit(n) && (t = e.createRangeIn(n));
+  }
+  for (const n of t.getItems())
+    if (!e.schema.isInline(n) || Array.from(n.getAttributeKeys()).find((r) => e.schema.getAttributeProperties(r).isFormatting)) return !1;
+  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 xe = class extends b {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "Clipboard";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [
+      Y,
+      D,
+      ve,
+      De
+    ];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const a = this.editor, e = this.editor.t;
+    a.accessibility.addKeystrokeInfos({ keystrokes: [
+      {
+        label: e("Copy selected content"),
+        keystroke: "CTRL+C"
+      },
+      {
+        label: e("Paste content"),
+        keystroke: "CTRL+V"
+      },
+      {
+        label: e("Paste content as plain text"),
+        keystroke: "CTRL+SHIFT+V"
+      }
+    ] });
+  }
+};
+export {
+  xe as Clipboard,
+  Y as ClipboardMarkersUtils,
+  v as ClipboardObserver,
+  D as ClipboardPipeline,
+  ve as DragDrop,
+  ke as DragDropBlockToolbar,
+  C as DragDropTarget,
+  De as PastePlainText,
+  fe as _ClipboardLineView,
+  ve as _DragDrop,
+  ke as _DragDropBlockToolbar,
+  C as _DragDropTarget,
+  ue as _normalizeClipboardData,
+  me as plainTextToHtml,
+  G as viewToPlainText
+};
+//# sourceMappingURL=index.js.map