@hkyhy/marsun-components-core 0.1.82 → 0.1.98

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

@@ -0,0 +1,755 @@
+var I = Object.defineProperty;
+var F = (i, e, t) => e in i ? I(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var h = (i, e, t) => F(i, typeof e != "symbol" ? e + "" : e, t);
+import { Plugin as k, Command as S } from "../../ckeditor5-core/dist/index.js";
+import { keyCodes as C, env as _, count as q, isInsideSurrogatePair as W, isInsideCombinedSymbol as Q, isInsideEmojiSequence as N, EventInfo as z } from "../../ckeditor5-utils/dist/index.js";
+import { _tryFixingModelRange as A, BubblingEventInfo as T, ViewDocumentDomEventData as y, Observer as O, ModelLiveRange as M, FocusObserver as U } from "../../ckeditor5-engine/dist/index.js";
+import { debounce as V } from "../../../es-toolkit/dist/compat/function/debounce.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
+*/
+var L = class {
+  /**
+  * Creates a new instance of the change buffer.
+  *
+  * @param limit The maximum number of atomic changes which can be contained in one batch.
+  */
+  constructor(i, e = 20) {
+    /**
+    * The model instance.
+    */
+    h(this, "model");
+    /**
+    * The maximum number of atomic changes which can be contained in one batch.
+    */
+    h(this, "limit");
+    /**
+    * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
+    */
+    h(this, "_isLocked");
+    /**
+    * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
+    * the {@link #batch batch} is set to a new one.
+    */
+    h(this, "_size");
+    /**
+    * The current batch instance.
+    */
+    h(this, "_batch", null);
+    /**
+    * The callback to document the change event which later needs to be removed.
+    */
+    h(this, "_changeCallback");
+    /**
+    * The callback to document selection `change:attribute` and `change:range` events which resets the buffer.
+    */
+    h(this, "_selectionChangeCallback");
+    this.model = i, this._size = 0, this.limit = e, this._isLocked = !1, this._changeCallback = (t, n) => {
+      n.isLocal && n.isUndoable && n !== this._batch && this._reset(!0);
+    }, this._selectionChangeCallback = () => {
+      this._reset();
+    }, this.model.document.on("change", this._changeCallback), this.model.document.selection.on("change:range", this._selectionChangeCallback), this.model.document.selection.on("change:attribute", this._selectionChangeCallback);
+  }
+  /**
+  * The current batch to which a feature should add its operations. Once the {@link #size}
+  * is reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+  */
+  get batch() {
+    return this._batch || (this._batch = this.model.createBatch({ isTyping: !0 })), this._batch;
+  }
+  /**
+  * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
+  * the {@link #batch batch} is set to a new one.
+  */
+  get size() {
+    return this._size;
+  }
+  /**
+  * The input number of changes into the buffer. Once the {@link #size} is
+  * reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+  *
+  * @param changeCount The number of atomic changes to input.
+  */
+  input(i) {
+    this._size += i, this._size >= this.limit && this._reset(!0);
+  }
+  /**
+  * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
+  */
+  get isLocked() {
+    return this._isLocked;
+  }
+  /**
+  * Locks the buffer.
+  */
+  lock() {
+    this._isLocked = !0;
+  }
+  /**
+  * Unlocks the buffer.
+  */
+  unlock() {
+    this._isLocked = !1;
+  }
+  /**
+  * Destroys the buffer.
+  */
+  destroy() {
+    this.model.document.off("change", this._changeCallback), this.model.document.selection.off("change:range", this._selectionChangeCallback), this.model.document.selection.off("change:attribute", this._selectionChangeCallback);
+  }
+  /**
+  * Resets the change buffer.
+  *
+  * @param ignoreLock Whether internal lock {@link #isLocked} should be ignored.
+  */
+  _reset(i = !1) {
+    (!this.isLocked || i) && (this._batch = null, this._size = 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 Y = class extends S {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param undoStepSize The maximum number of atomic changes
+  * which can be contained in one batch in the command buffer.
+  */
+  constructor(e, t) {
+    super(e);
+    /**
+    * Typing's change buffer used to group subsequent changes into batches.
+    */
+    h(this, "_buffer");
+    this._buffer = new L(e.model, t), this._isEnabledBasedOnSelection = !1;
+  }
+  /**
+  * The current change buffer.
+  */
+  get buffer() {
+    return this._buffer;
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    super.destroy(), this._buffer.destroy();
+  }
+  /**
+  * Executes the input command. It replaces the content within the given range with the given text.
+  * Replacing is a two step process, first the content within the range is removed and then the new text is inserted
+  * at the beginning of the range (which after the removal is a collapsed range).
+  *
+  * @fires execute
+  * @param options The command options.
+  */
+  execute(e = {}) {
+    const t = this.editor.model, n = t.document, o = e.text || "", s = o.length;
+    let l = n.selection;
+    if (e.selection ? l = e.selection : e.range && (l = t.createSelection(e.range)), !t.canEditAt(l)) return;
+    const c = e.resultRange;
+    t.enqueueChange(this._buffer.batch, (r) => {
+      this._buffer.lock();
+      const a = Array.from(n.selection.getAttributes());
+      t.deleteContent(l), o && t.insertContent(r.createText(o, a), l), c ? r.setSelection(c) : l.is("documentSelection") || r.setSelection(l), this._buffer.unlock(), this._buffer.input(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
+*/
+const P = ["insertText", "insertReplacementText"], $ = [...P, "insertCompositionText"];
+var H = class extends O {
+  /**
+  * @inheritDoc
+  */
+  constructor(e) {
+    super(e);
+    /**
+    * Instance of the focus observer. Insert text observer calls
+    * {@link module:engine/view/observer/focusobserver~FocusObserver#flush} to mark the latest focus change as complete.
+    */
+    h(this, "focusObserver");
+    this.focusObserver = e.getObserver(U);
+    const t = _.isAndroid ? $ : P, n = e.document;
+    n.on("beforeinput", (o, s) => {
+      if (!this.isEnabled) return;
+      const { data: l, targetRanges: c, inputType: r, domEvent: a, isComposing: d } = s;
+      if (!t.includes(r)) return;
+      this.focusObserver.flush();
+      const u = new z(n, "insertText");
+      n.fire(u, new y(e, a, {
+        text: l,
+        selection: e.createSelection(c),
+        isComposing: d
+      })), u.stop.called && o.stop();
+    }), _.isAndroid || n.on("compositionend", (o, { data: s, domEvent: l }) => {
+      this.isEnabled && s && n.fire("insertText", new y(e, l, {
+        text: s,
+        isComposing: !0
+      }));
+    }, { priority: "low" });
+  }
+  /**
+  * @inheritDoc
+  */
+  observe() {
+  }
+  /**
+  * @inheritDoc
+  */
+  stopObserving() {
+  }
+};
+/**
+* @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 K = class extends k {
+  constructor() {
+    super(...arguments);
+    /**
+    * The queue of `insertText` command executions that are waiting for the DOM to get updated after beforeinput event.
+    */
+    h(this, "_typingQueue");
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "Input";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.model, n = e.editing.view, o = e.editing.mapper, s = t.document.selection;
+    this._typingQueue = new j(e), n.addObserver(H);
+    const l = new Y(e, e.config.get("typing.undoStep") || 20);
+    e.commands.add("insertText", l), e.commands.add("input", l), this.listenTo(n.document, "beforeinput", () => {
+      this._typingQueue.flush("next beforeinput");
+    }, { priority: "high" }), this.listenTo(n.document, "insertText", (c, r) => {
+      const { text: a, selection: d } = r;
+      if (n.document.selection.isFake && d && n.document.selection.isSimilar(d) && r.preventDefault(), d && Array.from(d.getRanges()).some((f) => !f.isCollapsed) && r.preventDefault(), !l.isEnabled) {
+        r.preventDefault();
+        return;
+      }
+      let u;
+      d && (u = Array.from(d.getRanges()).filter((f) => f.root.is("rootElement")).map((f) => o.toModelRange(f)).map((f) => A(f, t.schema) || f)), (!u || !u.length) && (u = Array.from(s.getRanges()));
+      let m = a;
+      if (_.isAndroid) {
+        const f = Array.from(u[0].getItems()).reduce((E, w) => E + (w.is("$textProxy") ? w.data : ""), "");
+        if (f && (f.length <= m.length ? m.startsWith(f) && (m = m.substring(f.length), u[0].start = u[0].start.getShiftedBy(f.length)) : f.startsWith(m) && (u[0].start = u[0].start.getShiftedBy(m.length), m = "")), m.length == 0 && u[0].isCollapsed) return;
+      }
+      const g = {
+        text: m,
+        selection: t.createSelection(u)
+      };
+      this._typingQueue.push(g, !!r.isComposing), r.domEvent.defaultPrevented && this._typingQueue.flush("beforeinput default prevented");
+    }), _.isAndroid ? this.listenTo(n.document, "keydown", (c, r) => {
+      s.isCollapsed || r.keyCode != 229 || !n.document.isComposing || x(t, l);
+    }) : this.listenTo(n.document, "compositionstart", () => {
+      s.isCollapsed || x(t, l);
+    }, { priority: "high" }), this.listenTo(n.document, "mutations", (c, { mutations: r }) => {
+      if (this._typingQueue.hasAffectedElements()) for (const { node: a } of r) {
+        const d = J(a, o), u = o.toModelElement(d);
+        if (this._typingQueue.isElementAffected(u)) {
+          this._typingQueue.flush("mutations");
+          return;
+        }
+      }
+    }), this.listenTo(n.document, "compositionend", () => {
+      this._typingQueue.flush("before composition end");
+    }, { priority: "high" }), this.listenTo(n.document, "compositionend", () => {
+      this._typingQueue.flush("after composition end");
+      const c = [];
+      if (this._typingQueue.hasAffectedElements()) for (const r of this._typingQueue.flushAffectedElements()) {
+        const a = o.toViewElement(r);
+        a && c.push({
+          type: "children",
+          node: a
+        });
+      }
+      (c.length || !_.isAndroid) && n.document.fire("mutations", { mutations: c });
+    }, { priority: "lowest" });
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    super.destroy(), this._typingQueue.destroy();
+  }
+}, j = class {
+  /**
+  * @inheritDoc
+  */
+  constructor(i) {
+    /**
+    * The editor instance.
+    */
+    h(this, "editor");
+    /**
+    * Debounced queue flush as a safety mechanism for cases of mutation observer not triggering.
+    */
+    h(this, "flushDebounced", V(() => this.flush("timeout"), 50));
+    /**
+    * The queue of `insertText` command executions that are waiting for the DOM to get updated after beforeinput event.
+    */
+    h(this, "_queue", []);
+    /**
+    * Whether there is any composition enqueued or plain typing only.
+    */
+    h(this, "_isComposing", !1);
+    /**
+    * A set of model elements. The typing happened in those elements. It's used for mutations check.
+    */
+    h(this, "_affectedElements", /* @__PURE__ */ new Set());
+    this.editor = i;
+  }
+  /**
+  * Destroys the helper object.
+  */
+  destroy() {
+    for (this.flushDebounced.cancel(), this._affectedElements.clear(); this._queue.length; ) this.shift();
+  }
+  /**
+  * Returns the size of the queue.
+  */
+  get length() {
+    return this._queue.length;
+  }
+  /**
+  * Push next insertText command data to the queue.
+  */
+  push(i, e) {
+    const t = { text: i.text };
+    if (i.selection) {
+      t.selectionRanges = [];
+      for (const n of i.selection.getRanges())
+        t.selectionRanges.push(M.fromRange(n)), this._affectedElements.add(n.start.parent);
+    }
+    this._queue.push(t), this._isComposing || (this._isComposing = e), this.flushDebounced();
+  }
+  /**
+  * Shift the first item from the insertText command data queue.
+  */
+  shift() {
+    const i = this._queue.shift(), e = { text: i.text };
+    if (i.selectionRanges) {
+      const t = i.selectionRanges.map((n) => G(n)).filter((n) => !!n);
+      t.length && (e.selection = this.editor.model.createSelection(t));
+    }
+    return e;
+  }
+  /**
+  * Applies all queued insertText command executions.
+  *
+  * @param reason Used only for debugging.
+  */
+  flush(i) {
+    const e = this.editor, t = e.model, n = e.editing.view;
+    if (this.flushDebounced.cancel(), !this._queue.length) return;
+    const o = e.commands.get("insertText").buffer;
+    t.enqueueChange(o.batch, () => {
+      for (o.lock(); this._queue.length; ) {
+        const s = this.shift();
+        e.execute("insertText", s);
+      }
+      o.unlock(), this._isComposing || this._affectedElements.clear(), this._isComposing = !1;
+    }), n.scrollToTheSelection();
+  }
+  /**
+  * Returns `true` if the given model element is related to recent typing.
+  */
+  isElementAffected(i) {
+    return this._affectedElements.has(i);
+  }
+  /**
+  * Returns `true` if there are any affected elements in the queue.
+  */
+  hasAffectedElements() {
+    return this._affectedElements.size > 0;
+  }
+  /**
+  * Returns an array of typing-related elements and clears the internal list.
+  */
+  flushAffectedElements() {
+    const i = Array.from(this._affectedElements);
+    return this._affectedElements.clear(), i;
+  }
+};
+function x(i, e) {
+  if (!e.isEnabled) return;
+  const t = e.buffer;
+  t.lock(), i.enqueueChange(t.batch, () => {
+    i.deleteContent(i.document.selection);
+  }), t.unlock();
+}
+function G(i) {
+  const e = i.toRange();
+  return i.detach(), e.root.rootName == "$graveyard" ? null : e;
+}
+function J(i, e) {
+  let t = i.is("$text") ? i.parent : i;
+  for (; !e.toModelElement(t); ) t = t.parent;
+  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
+*/
+var R = class extends S {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param direction The directionality of the delete describing in what direction it
+  * should consume the content when the selection is collapsed.
+  */
+  constructor(e, t) {
+    super(e);
+    /**
+    * The directionality of the delete describing in what direction it should
+    * consume the content when the selection is collapsed.
+    */
+    h(this, "direction");
+    /**
+    * Delete's change buffer used to group subsequent changes into batches.
+    */
+    h(this, "_buffer");
+    this.direction = t, this._buffer = new L(e.model, e.config.get("typing.undoStep")), this._isEnabledBasedOnSelection = !1;
+  }
+  /**
+  * The current change buffer.
+  */
+  get buffer() {
+    return this._buffer;
+  }
+  /**
+  * Executes the delete command. Depending on whether the selection is collapsed or not, deletes its content
+  * or a piece of content in the {@link #direction defined direction}.
+  *
+  * @fires execute
+  * @param options The command options.
+  * @param options.unit See {@link module:engine/model/utils/modifyselection~modifySelection}'s options.
+  * @param options.sequence A number describing which subsequent delete event it is without the key being released.
+  * See the {@link module:engine/view/document~ViewDocument#event:delete} event data.
+  * @param options.selection Selection to remove. If not set, current model selection will be used.
+  */
+  execute(e = {}) {
+    const t = this.editor.model, n = t.document;
+    t.enqueueChange(this._buffer.batch, (o) => {
+      this._buffer.lock();
+      const s = o.createSelection(e.selection || n.selection);
+      if (!t.canEditAt(s)) return;
+      const l = e.sequence || 1, c = s.isCollapsed;
+      if (s.isCollapsed && t.modifySelection(s, {
+        direction: this.direction,
+        unit: e.unit,
+        treatEmojiAsSingleUnit: !0
+      }), this._shouldEntireContentBeReplacedWithParagraph(l)) {
+        this._replaceEntireContentWithParagraph(o);
+        return;
+      }
+      if (this._shouldReplaceFirstBlockWithParagraph(s, l)) {
+        this.editor.execute("paragraph", { selection: s });
+        return;
+      }
+      if (s.isCollapsed) return;
+      let r = 0;
+      s.getFirstRange().getMinimalFlatRanges().forEach((a) => {
+        r += q(a.getWalker({
+          singleCharacters: !0,
+          ignoreElementEnd: !0,
+          shallow: !0
+        }));
+      }), t.deleteContent(s, {
+        doNotResetEntireContent: c,
+        direction: this.direction
+      }), this._buffer.input(r), o.setSelection(s), this._buffer.unlock();
+    });
+  }
+  /**
+  * If the user keeps <kbd>Backspace</kbd> or <kbd>Delete</kbd> key pressed, the content of the current
+  * editable will be cleared. However, this will not yet lead to resetting the remaining block to a paragraph
+  * (which happens e.g. when the user does <kbd>Ctrl</kbd> + <kbd>A</kbd>, <kbd>Backspace</kbd>).
+  *
+  * But, if the user pressed the key in an empty editable for the first time,
+  * we want to replace the entire content with a paragraph if:
+  *
+  * * the current limit element is empty,
+  * * the paragraph is allowed in the limit element,
+  * * the limit doesn't already have a paragraph inside.
+  *
+  * See https://github.com/ckeditor/ckeditor5-typing/issues/61.
+  *
+  * @param sequence A number describing which subsequent delete event it is without the key being released.
+  */
+  _shouldEntireContentBeReplacedWithParagraph(e) {
+    if (e > 1) return !1;
+    const t = this.editor.model, n = t.document.selection, o = t.schema.getLimitElement(n);
+    if (!(n.isCollapsed && n.containsEntireContent(o)) || !t.schema.checkChild(o, "paragraph")) return !1;
+    const s = o.getChild(0);
+    return !(s && s.is("element", "paragraph"));
+  }
+  /**
+  * The entire content is replaced with the paragraph. Selection is moved inside the paragraph.
+  *
+  * @param writer The model writer.
+  */
+  _replaceEntireContentWithParagraph(e) {
+    const t = this.editor.model, n = t.document.selection, o = t.schema.getLimitElement(n), s = e.createElement("paragraph");
+    e.remove(e.createRangeIn(o)), e.insert(s, o), e.setSelection(s, 0);
+  }
+  /**
+  * Checks if the selection is inside an empty element that is the first child of the limit element
+  * and should be replaced with a paragraph.
+  *
+  * @param selection The selection.
+  * @param sequence A number describing which subsequent delete event it is without the key being released.
+  */
+  _shouldReplaceFirstBlockWithParagraph(e, t) {
+    const n = this.editor.model;
+    if (t > 1 || this.direction != "backward" || !e.isCollapsed) return !1;
+    const o = e.getFirstPosition(), s = n.schema.getLimitElement(o), l = s.getChild(0);
+    return !(o.parent != l || !e.containsEntireContent(l) || !n.schema.checkChild(s, "paragraph") || l.name == "paragraph");
+  }
+};
+/**
+* @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 X = "character", D = "word", Z = "codePoint", p = "selection", b = "backward", v = "forward", B = {
+  deleteContent: {
+    unit: p,
+    direction: b
+  },
+  deleteContentBackward: {
+    unit: Z,
+    direction: b
+  },
+  deleteWordBackward: {
+    unit: D,
+    direction: b
+  },
+  deleteHardLineBackward: {
+    unit: p,
+    direction: b
+  },
+  deleteSoftLineBackward: {
+    unit: p,
+    direction: b
+  },
+  deleteContentForward: {
+    unit: X,
+    direction: v
+  },
+  deleteWordForward: {
+    unit: D,
+    direction: v
+  },
+  deleteHardLineForward: {
+    unit: p,
+    direction: v
+  },
+  deleteSoftLineForward: {
+    unit: p,
+    direction: v
+  }
+};
+var ee = class extends O {
+  /**
+  * @inheritDoc
+  */
+  constructor(i) {
+    super(i);
+    const e = i.document;
+    let t = 0;
+    e.on("keydown", () => {
+      t++;
+    }), e.on("keyup", () => {
+      t = 0;
+    }), e.on("beforeinput", (n, o) => {
+      if (!this.isEnabled) return;
+      const { targetRanges: s, domEvent: l, inputType: c } = o, r = B[c];
+      if (!r) return;
+      const a = {
+        direction: r.direction,
+        unit: r.unit,
+        sequence: t
+      };
+      a.unit == p && (a.selectionToRemove = i.createSelection(s[0])), c === "deleteContentBackward" && (_.isAndroid && (a.sequence = 1), ne(s) && (a.unit = p, a.selectionToRemove = i.createSelection(s)));
+      const d = new T(e, "delete", s[0]);
+      e.fire(d, new y(i, l, a)), d.stop.called && n.stop();
+    }), _.isBlink && te(this);
+  }
+  /**
+  * @inheritDoc
+  */
+  observe() {
+  }
+  /**
+  * @inheritDoc
+  */
+  stopObserving() {
+  }
+};
+function te(i) {
+  const e = i.view, t = e.document;
+  let n = null, o = !1;
+  t.on("keydown", (c, { keyCode: r }) => {
+    n = r, o = !1;
+  }), t.on("keyup", (c, { keyCode: r, domEvent: a }) => {
+    const d = t.selection, u = i.isEnabled && r == n && s(r) && !d.isCollapsed && !o;
+    if (n = null, u) {
+      const m = d.getFirstRange(), g = new T(t, "delete", m), f = {
+        unit: p,
+        direction: l(r),
+        selectionToRemove: d
+      };
+      t.fire(g, new y(e, a, f));
+    }
+  }), t.on("beforeinput", (c, { inputType: r }) => {
+    const a = B[r];
+    s(n) && a && a.direction == l(n) && (o = !0);
+  }, { priority: "high" }), t.on("beforeinput", (c, { inputType: r, data: a }) => {
+    n == C.delete && r == "insertText" && a == "" && c.stop();
+  }, { priority: "high" });
+  function s(c) {
+    return c == C.backspace || c == C.delete;
+  }
+  function l(c) {
+    return c == C.backspace ? b : v;
+  }
+}
+function ne(i) {
+  if (i.length != 1 || i[0].isCollapsed) return !1;
+  const e = i[0].getWalker({
+    direction: "backward",
+    singleCharacters: !0,
+    ignoreElementEnd: !0
+  });
+  let t = 0;
+  for (const { nextPosition: n, item: o } of e) {
+    if (n.parent.is("$text")) {
+      const s = n.parent.data, l = n.offset;
+      if (W(s, l) || Q(s, l) || N(s, l)) continue;
+      t++;
+    } else (o.is("containerElement") || o.is("emptyElement")) && t++;
+    if (t > 1) return !0;
+  }
+  return !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 ie = class extends k {
+  constructor() {
+    super(...arguments);
+    /**
+    * Whether pressing backspace should trigger undo action
+    */
+    h(this, "_undoOnBackspace");
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "Delete";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.editing.view, n = t.document, o = e.model.document;
+    t.addObserver(ee), this._undoOnBackspace = !1;
+    const s = new R(e, "forward");
+    e.commands.add("deleteForward", s), e.commands.add("forwardDelete", s), e.commands.add("delete", new R(e, "backward")), this.listenTo(n, "delete", (l, c) => {
+      n.isComposing || c.preventDefault();
+      const { direction: r, sequence: a, selectionToRemove: d, unit: u } = c, m = r === "forward" ? "deleteForward" : "delete", g = { sequence: a };
+      if (u == "selection") {
+        const f = Array.from(d.getRanges()).map((E) => e.editing.mapper.toModelRange(E)).map((E) => A(E, e.model.schema) || E);
+        g.selection = e.model.createSelection(f);
+      } else g.unit = u;
+      e.execute(m, g), t.scrollToTheSelection();
+    }, { priority: "low" }), this.listenTo(n, "keydown", (l, c) => {
+      if (n.isComposing || c.keyCode != C.backspace || !o.selection.isCollapsed) return;
+      const r = e.model.schema.getLimitElement(o.selection), a = e.model.createPositionAt(r, 0);
+      if (a.isTouching(o.selection.getFirstPosition())) {
+        c.preventDefault();
+        const d = e.model.schema.getNearestSelectionRange(a, "forward");
+        if (!d) return;
+        const u = t.createSelection(e.editing.mapper.toViewRange(d)), m = u.getFirstRange(), g = new T(document, "delete", m), f = {
+          unit: "selection",
+          direction: "backward",
+          selectionToRemove: u
+        };
+        n.fire(g, new y(t, c.domEvent, f));
+      }
+    }), this.editor.plugins.has("UndoEditing") && (this.listenTo(n, "delete", (l, c) => {
+      this._undoOnBackspace && c.direction == "backward" && c.sequence == 1 && c.unit == "codePoint" && (this._undoOnBackspace = !1, e.execute("undo"), c.preventDefault(), l.stop());
+    }, { context: "$capture" }), this.listenTo(o, "change", () => {
+      this._undoOnBackspace = !1;
+    }));
+  }
+  /**
+  * If the next user action after calling this method is pressing backspace, it would undo the last change.
+  *
+  * Requires {@link module:undo/undoediting~UndoEditing} plugin. If not loaded, does nothing.
+  */
+  requestUndoOnBackspace() {
+    this.editor.plugins.has("UndoEditing") && (this._undoOnBackspace = !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 ae = class extends k {
+  static get requires() {
+    return [K, ie];
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "Typing";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+};
+export {
+  ie as Delete,
+  R as DeleteCommand,
+  K as Input,
+  Y as InsertTextCommand,
+  H as InsertTextObserver,
+  ae as Typing,
+  L as TypingChangeBuffer,
+  ee as _DeleteObserver
+};
+//# sourceMappingURL=index.js.map