@hkyhy/marsun-components-core 0.1.89 → 0.1.98

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

@@ -0,0 +1,2042 @@
+var dt = Object.defineProperty;
+var ft = (e, t, i) => t in e ? dt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var h = (e, t, i) => ft(e, typeof t != "symbol" ? t + "" : t, i);
+import { Plugin as _, Command as D } from "../../ckeditor5-core/dist/index.js";
+import { Delete as gt } from "../../ckeditor5-typing/dist/index.js";
+import { Enter as pt } from "../../ckeditor5-enter/dist/index.js";
+import { CKEditorError as It, toArray as B, first as ht, env as q, uid as bt } from "../../ckeditor5-utils/dist/index.js";
+import { _normalizeFontSizeOptions as U } from "../../ckeditor5-font/dist/index.js";
+import { ClipboardPipeline as kt } from "../../ckeditor5-clipboard/dist/index.js";
+import { ButtonView as At, MenuBarMenuListItemButtonView as yt } from "../../ckeditor5-ui/dist/index.js";
+import { IconNumberedList as Lt, IconBulletedList as _t } from "../../ckeditor5-icons/dist/index.js";
+import "../../ckeditor5-engine/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
+*/
+var A = class {
+  /**
+  * Creates a document list iterator.
+  *
+  * @param startElement The start list item block element.
+  * @param options.direction The iterating direction.
+  * @param options.includeSelf Whether start block should be included in the result (if it's matching other criteria).
+  * @param options.sameAttributes Additional attributes that must be the same for each block.
+  * @param options.sameIndent Whether blocks with the same indent level as the start block should be included
+  * in the result.
+  * @param options.lowerIndent Whether blocks with a lower indent level than the start block should be included
+  * in the result.
+  * @param options.higherIndent Whether blocks with a higher indent level than the start block should be included
+  * in the result.
+  */
+  constructor(e, t) {
+    /**
+    * The start list item block element.
+    */
+    h(this, "_startElement");
+    /**
+    * The reference indent. Initialized by the indent of the start block.
+    */
+    h(this, "_referenceIndent");
+    /**
+    * The iterating direction.
+    */
+    h(this, "_isForward");
+    /**
+    * Whether start block should be included in the result (if it's matching other criteria).
+    */
+    h(this, "_includeSelf");
+    /**
+    * Additional attributes that must be the same for each block.
+    */
+    h(this, "_sameAttributes");
+    /**
+    * Whether blocks with the same indent level as the start block should be included in the result.
+    */
+    h(this, "_sameIndent");
+    /**
+    * Whether blocks with a lower indent level than the start block should be included in the result.
+    */
+    h(this, "_lowerIndent");
+    /**
+    * Whether blocks with a higher indent level than the start block should be included in the result.
+    */
+    h(this, "_higherIndent");
+    this._startElement = e, this._referenceIndent = e.getAttribute("listIndent"), this._isForward = t.direction == "forward", this._includeSelf = !!t.includeSelf, this._sameAttributes = B(t.sameAttributes || []), this._sameIndent = !!t.sameIndent, this._lowerIndent = !!t.lowerIndent, this._higherIndent = !!t.higherIndent;
+  }
+  /**
+  * Performs only first step of iteration and returns the result.
+  *
+  * @param startElement The start list item block element.
+  * @param options.direction The iterating direction.
+  * @param options.includeSelf Whether start block should be included in the result (if it's matching other criteria).
+  * @param options.sameAttributes Additional attributes that must be the same for each block.
+  * @param options.sameIndent Whether blocks with the same indent level as the start block should be included
+  * in the result.
+  * @param options.lowerIndent Whether blocks with a lower indent level than the start block should be included
+  * in the result.
+  * @param options.higherIndent Whether blocks with a higher indent level than the start block should be included
+  * in the result.
+  */
+  static first(e, t) {
+    const i = new this(e, t)[Symbol.iterator]();
+    return ht(i);
+  }
+  /**
+  * Iterable interface.
+  */
+  *[Symbol.iterator]() {
+    const e = [];
+    for (const { node: t } of new P(this._getStartNode(), this._isForward ? "forward" : "backward")) {
+      const i = t.getAttribute("listIndent");
+      if (i < this._referenceIndent) {
+        if (!this._lowerIndent) break;
+        this._referenceIndent = i;
+      } else if (i > this._referenceIndent) {
+        if (!this._higherIndent) continue;
+        if (!this._isForward) {
+          e.push(t);
+          continue;
+        }
+      } else {
+        if (!this._sameIndent) {
+          if (this._higherIndent) {
+            e.length && (yield* e, e.length = 0);
+            break;
+          }
+          continue;
+        }
+        if (this._sameAttributes.some((s) => t.getAttribute(s) !== this._startElement.getAttribute(s))) break;
+      }
+      e.length && (yield* e, e.length = 0), yield t;
+    }
+  }
+  /**
+  * Returns the model element to start iterating.
+  */
+  _getStartNode() {
+    return this._includeSelf ? this._startElement : this._isForward ? this._startElement.nextSibling : this._startElement.previousSibling;
+  }
+}, P = class {
+  /**
+  * @param node The model node.
+  * @param direction Iteration direction.
+  */
+  constructor(e, t = "forward") {
+    h(this, "_node");
+    h(this, "_isForward");
+    h(this, "_previousNodesByIndent", []);
+    h(this, "_previous", null);
+    h(this, "_previousNodeIndent", null);
+    this._node = e, this._isForward = t === "forward";
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    if (!I(this._node)) return {
+      done: !0,
+      value: void 0
+    };
+    const e = this._node.getAttribute("listIndent");
+    let t = null;
+    if (this._previous) {
+      const s = this._previousNodeIndent;
+      e > s ? this._previousNodesByIndent[s] = this._previous : e < s ? (t = this._previousNodesByIndent[e] || null, this._previousNodesByIndent.length = e) : t = this._previous;
+    }
+    const i = {
+      node: this._node,
+      previous: this._previous,
+      previousNodeInList: t
+    };
+    return this._previous = this._node, this._previousNodeIndent = e, this._node = this._isForward ? this._node.nextSibling : this._node.previousSibling, {
+      value: i,
+      done: !1
+    };
+  }
+}, St = class {
+  /**
+  * @param listHead The head element of a list.
+  */
+  constructor(e) {
+    h(this, "_listHead");
+    this._listHead = e;
+  }
+  /**
+  * List blocks iterator.
+  *
+  * Iterates over all blocks of a list.
+  */
+  [Symbol.iterator]() {
+    return new P(this._listHead);
+  }
+};
+/**
+* @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 F = class {
+  /**
+  * Returns the next ID.
+  *
+  * @internal
+  */
+  /* istanbul ignore next: static function definition -- @preserve */
+  static next() {
+    return bt();
+  }
+};
+function I(e) {
+  return !!e && e.is("element") && e.hasAttribute("listItemId");
+}
+function E(e, t = {}) {
+  return [...S(e, {
+    ...t,
+    direction: "backward"
+  }), ...S(e, {
+    ...t,
+    direction: "forward"
+  })];
+}
+function S(e, t = {}) {
+  const i = t.direction == "forward", s = Array.from(new A(e, {
+    ...t,
+    includeSelf: i,
+    sameIndent: !0,
+    sameAttributes: "listItemId"
+  }));
+  return i ? s : s.reverse();
+}
+function vt(e) {
+  return Array.from(new A(e, {
+    direction: "forward",
+    higherIndent: !0
+  }));
+}
+function ot(e, t) {
+  const i = new A(e, {
+    sameIndent: !0,
+    sameAttributes: "listType",
+    ...t
+  }), s = new A(e, {
+    sameIndent: !0,
+    sameAttributes: "listType",
+    includeSelf: !0,
+    direction: "forward",
+    ...t
+  });
+  return [...Array.from(i).reverse(), ...s];
+}
+function v(e) {
+  return !A.first(e, {
+    sameIndent: !0,
+    sameAttributes: "listItemId"
+  });
+}
+function H(e) {
+  return !A.first(e, {
+    direction: "forward",
+    sameIndent: !0,
+    sameAttributes: "listItemId"
+  });
+}
+function N(e, t = {}) {
+  e = B(e);
+  const i = t.withNested !== !1, s = /* @__PURE__ */ new Set();
+  for (const n of e) for (const r of E(n, { higherIndent: i })) s.add(r);
+  return w(s);
+}
+function wt(e) {
+  e = B(e);
+  const t = /* @__PURE__ */ new Set();
+  for (const i of e) for (const s of ot(i)) t.add(s);
+  return w(t);
+}
+function K(e, t) {
+  const i = S(e, { direction: "forward" }), s = F.next();
+  for (const n of i) t.setAttribute("listItemId", s, n);
+  return i;
+}
+function $(e, t, i) {
+  const s = {};
+  for (const [r, o] of t.getAttributes()) r.startsWith("list") && (s[r] = o);
+  const n = S(e, { direction: "forward" });
+  for (const r of n) i.setAttributes(s, r);
+  return n;
+}
+function j(e, t, { expand: i, indentBy: s = 1, attributeNames: n }) {
+  e = B(e);
+  const r = i ? N(e) : e;
+  for (const o of r) {
+    const l = o.getAttribute("listIndent") + s;
+    l < 0 ? z(o, t, n) : t.setAttribute("listIndent", l, o);
+  }
+  return r;
+}
+function Ft(e, t, { attributeNames: i }) {
+  e = B(e);
+  const s = N(e), n = /* @__PURE__ */ new Set(), r = Math.min(...s.map((l) => l.getAttribute("listIndent"))), o = /* @__PURE__ */ new Map();
+  for (const l of s) o.set(l, A.first(l, { lowerIndent: !0 }));
+  for (const l of s) {
+    if (n.has(l)) continue;
+    n.add(l);
+    const a = l.getAttribute("listIndent") - 1;
+    if (a < 0) {
+      z(l, t, i);
+      continue;
+    }
+    if (l.getAttribute("listIndent") == r && o.get(l)) {
+      const u = Tt(l, o.get(l), t);
+      for (const c of u) n.add(c);
+      if (u.length) continue;
+    }
+    t.setAttribute("listIndent", a, l);
+  }
+  return w(n);
+}
+function z(e, t, i) {
+  e = B(e);
+  for (const s of e) s.is("element", "listItem") && t.rename(s, "paragraph");
+  for (const s of e) for (const n of s.getAttributeKeys()) i.includes(n) && t.removeAttribute(n, s);
+  return e;
+}
+function T(e) {
+  if (!e.length) return !1;
+  const t = e[0].getAttribute("listItemId");
+  return t ? !e.some((i) => i.getAttribute("listItemId") != t) : !1;
+}
+function Bt(e, t) {
+  const i = [];
+  let s = Number.POSITIVE_INFINITY;
+  for (const { node: n } of new P(e.nextSibling)) {
+    const r = n.getAttribute("listIndent");
+    if (r == 0) break;
+    r < s && (s = r);
+    const o = r - s;
+    t.setAttribute("listIndent", o, n), i.push(n);
+  }
+  return i;
+}
+function w(e) {
+  return Array.from(e).filter((t) => t.root.rootName !== "$graveyard").sort((t, i) => t.index - i.index);
+}
+function x(e) {
+  const t = e.document.selection.getSelectedElement();
+  return t && e.schema.isObject(t) && e.schema.isBlock(t) ? t : null;
+}
+function R(e, t) {
+  return t.checkChild(e.parent, "listItem") && t.checkChild(e, "$text") && !t.isObject(e);
+}
+function Et(e) {
+  return e == "numbered" || e == "customNumbered";
+}
+function Ct(e) {
+  const t = e.getAttribute("listIndent"), i = e.getAttribute("listType"), s = e.getAttribute("listItemId");
+  let n = e.previousSibling, r = !1;
+  for (; I(n); ) {
+    const o = n.getAttribute("listIndent");
+    if (o < t) return !0;
+    if (o === t)
+      return n.getAttribute("listItemId") === s ? !1 : n.getAttribute("listType") !== i;
+    r = !0, n = n.previousSibling;
+  }
+  return !r;
+}
+function Tt(e, t, i) {
+  return S(t, { direction: "forward" }).pop().index > e.index ? $(e, t, i) : [];
+}
+/**
+* @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 D {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param editor The editor instance.
+  * @param indentDirection The direction of indent. If it is equal to `backward`, the command
+  * will outdent a list item.
+  */
+  constructor(t, i) {
+    super(t);
+    /**
+    * Determines by how much the command will change the list item's indent attribute.
+    */
+    h(this, "_direction");
+    this._direction = i;
+  }
+  /**
+  * @inheritDoc
+  */
+  refresh() {
+    this.isEnabled = this._checkEnabled();
+  }
+  /**
+  * Indents or outdents (depending on the {@link #constructor}'s `indentDirection` parameter) selected list items.
+  *
+  * @fires execute
+  * @fires afterExecute
+  */
+  execute() {
+    const t = this.editor, i = t.model, s = G(i.document.selection), n = t.plugins.get("ListEditing").getListAttributeNames();
+    i.change((r) => {
+      const o = [];
+      T(s) && !v(s[0]) ? (this._direction == "forward" && o.push(...j(s, r, { attributeNames: n })), o.push(...K(s[0], r))) : this._direction == "forward" ? o.push(...j(s, r, {
+        expand: !0,
+        attributeNames: n
+      })) : o.push(...Ft(s, r, { attributeNames: n }));
+      for (const l of o) {
+        if (!l.hasAttribute("listType")) continue;
+        const a = A.first(l, { sameIndent: !0 });
+        a && r.setAttribute("listType", a.getAttribute("listType"), l);
+      }
+      this._fireAfterExecute(o);
+    });
+  }
+  /**
+  * Fires the `afterExecute` event.
+  *
+  * @param changedBlocks The changed list elements.
+  */
+  _fireAfterExecute(t) {
+    this.fire("afterExecute", w(new Set(t)));
+  }
+  /**
+  * Checks whether the command can be enabled in the current context.
+  *
+  * @returns Whether the command should be enabled.
+  */
+  _checkEnabled() {
+    let t = G(this.editor.model.document.selection), i = t[0];
+    if (!i) return !1;
+    if (this._direction == "backward" || T(t) && !v(t[0]) || this.editor.config.get("list.enableSkipLevelLists")) return !0;
+    t = N(t), i = t[0];
+    const s = A.first(i, { sameIndent: !0 });
+    return s ? s.getAttribute("listType") == i.getAttribute("listType") : !1;
+  }
+};
+function G(e) {
+  const t = Array.from(e.getSelectedBlocks()), i = t.findIndex((s) => !I(s));
+  return i != -1 && (t.length = i), 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 M = class extends D {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param editor The editor instance.
+  * @param type List type that will be handled by this command.
+  */
+  constructor(t, i, s = {}) {
+    super(t);
+    /**
+    * The type of the list created by the command.
+    */
+    h(this, "type");
+    /**
+    * List Walker options that change the range of the list items to be changed when the selection is collapsed within a list item.
+    *
+    * In a multi-level list, when the selection is collapsed within a list item, instead of changing only the list items of the same list
+    * type and current indent level, the entire list structure is changed (all list items at all indent levels of any list type).
+    */
+    h(this, "_listWalkerOptions");
+    this.type = i, this._listWalkerOptions = s.multiLevel ? {
+      higherIndent: !0,
+      lowerIndent: !0,
+      sameAttributes: []
+    } : void 0;
+  }
+  /**
+  * @inheritDoc
+  */
+  refresh() {
+    this.value = this._getValue(), this.isEnabled = this._checkEnabled();
+  }
+  /**
+  * Executes the list command.
+  *
+  * @fires execute
+  * @fires afterExecute
+  * @param options Command options.
+  * @param options.forceValue If set, it will force the command behavior. If `true`, the command will try to convert the
+  * selected items and potentially the neighbor elements to the proper list items. If set to `false` it will convert selected elements
+  * to paragraphs. If not set, the command will toggle selected elements to list items or paragraphs, depending on the selection.
+  * @param options.additionalAttributes Additional attributes that are set for list items when the command is executed.
+  */
+  execute(t = {}) {
+    const i = this.editor.model, s = i.document, n = x(i), r = Array.from(s.selection.getSelectedBlocks()).filter((l) => i.schema.checkAttribute(l, "listType") || R(l, i.schema)), o = t.forceValue !== void 0 ? !t.forceValue : this.value;
+    i.change((l) => {
+      if (o) {
+        const a = r[r.length - 1], u = this.editor.plugins.get("ListEditing").getListAttributeNames(), c = S(a, { direction: "forward" }), d = [];
+        c.length > 1 && d.push(...K(c[1], l)), d.push(...z(r, l, u)), d.push(...Bt(a, l)), this._fireAfterExecute(d);
+      } else if ((n || s.selection.isCollapsed) && I(r[0])) {
+        const a = ot(n || r[0], this._listWalkerOptions);
+        for (const u of a) l.setAttributes({
+          ...t.additionalAttributes,
+          listType: this.type
+        }, u);
+        this._fireAfterExecute(a);
+      } else {
+        const a = [];
+        for (const u of r) if (!u.hasAttribute("listType"))
+          !u.is("element", "listItem") && R(u, i.schema) && l.rename(u, "listItem"), l.setAttributes({
+            ...t.additionalAttributes,
+            listIndent: 0,
+            listItemId: F.next(),
+            listType: this.type
+          }, u), a.push(u);
+        else for (const c of N(u, { withNested: !1 })) c.getAttribute("listType") != this.type && (l.setAttributes({
+          ...t.additionalAttributes,
+          listType: this.type
+        }, c), a.push(c));
+        this._fireAfterExecute(a);
+      }
+    });
+  }
+  /**
+  * Fires the `afterExecute` event.
+  *
+  * @param changedBlocks The changed list elements.
+  */
+  _fireAfterExecute(t) {
+    this.fire("afterExecute", w(new Set(t)));
+  }
+  /**
+  * Checks the command's {@link #value}.
+  *
+  * @returns The current value.
+  */
+  _getValue() {
+    const t = this.editor.model.document.selection, i = Array.from(t.getSelectedBlocks());
+    if (!i.length) return !1;
+    for (const s of i) if (s.getAttribute("listType") != this.type) return !1;
+    return !0;
+  }
+  /**
+  * Checks whether the command can be enabled in the current context.
+  *
+  * @returns Whether the command should be enabled.
+  */
+  _checkEnabled() {
+    const t = this.editor.model, i = t.schema, s = t.document.selection, n = Array.from(s.getSelectedBlocks());
+    if (!n.length) return !1;
+    if (this.value) return !0;
+    for (const r of n) if (i.checkAttribute(r, "listType") || R(r, i)) 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 J = class extends D {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param editor The editor instance.
+  * @param direction Whether list item should be merged before or after the selected block.
+  */
+  constructor(t, i) {
+    super(t);
+    /**
+    * Whether list item should be merged before or after the selected block.
+    */
+    h(this, "_direction");
+    this._direction = i;
+  }
+  /**
+  * @inheritDoc
+  */
+  refresh() {
+    this.isEnabled = this._checkEnabled();
+  }
+  /**
+  * Merges list blocks together (depending on the {@link #constructor}'s `direction` parameter).
+  *
+  * @fires execute
+  * @fires afterExecute
+  * @param options Command options.
+  * @param options.shouldMergeOnBlocksContentLevel When set `true`, merging will be performed together
+  * with {@link module:engine/model/model~Model#deleteContent} to get rid of the inline content in the selection or take advantage
+  * of the heuristics in `deleteContent()` that helps convert lists into paragraphs in certain cases.
+  */
+  execute({ shouldMergeOnBlocksContentLevel: t = !1 } = {}) {
+    const i = this.editor, s = i.model, n = s.document.selection, r = [], o = i.plugins.get("ListEditing").getListAttributeNames();
+    s.change((l) => {
+      const { firstElement: a, lastElement: u } = this._getMergeSubjectElements(n, t);
+      if (!a || !u) return;
+      const c = a.getAttribute("listIndent") || 0, d = u.getAttribute("listIndent"), m = u.getAttribute("listItemId");
+      if (c != d) {
+        const g = vt(u);
+        r.push(...j([u, ...g], l, {
+          indentBy: c - d,
+          expand: c < d,
+          attributeNames: o
+        }));
+      }
+      if (t) {
+        let g = n;
+        n.isCollapsed && (g = l.createSelection(l.createRange(l.createPositionAt(a, "end"), l.createPositionAt(u, 0)))), s.deleteContent(g, { doNotResetEntireContent: n.isCollapsed });
+        const p = g.getLastPosition().parent, f = p.nextSibling;
+        r.push(p), f && f !== u && f.getAttribute("listItemId") == m && r.push(...$(f, p, l));
+      } else r.push(...$(u, a, l));
+      this._fireAfterExecute(r);
+    });
+  }
+  /**
+  * Fires the `afterExecute` event.
+  *
+  * @param changedBlocks The changed list elements.
+  */
+  _fireAfterExecute(t) {
+    this.fire("afterExecute", w(new Set(t)));
+  }
+  /**
+  * Checks whether the command can be enabled in the current context.
+  *
+  * @returns Whether the command should be enabled.
+  */
+  _checkEnabled() {
+    const t = this.editor.model, i = t.document.selection, s = x(t);
+    if (i.isCollapsed || s) {
+      const n = s || i.getFirstPosition().parent;
+      if (!I(n)) return !1;
+      const r = this._direction == "backward" ? n.previousSibling : n.nextSibling;
+      if (!r || T([n, r])) return !1;
+    } else {
+      const n = i.getLastPosition(), r = i.getFirstPosition();
+      if (n.parent === r.parent || !I(n.parent)) return !1;
+    }
+    return !0;
+  }
+  /**
+  * Returns the boundary elements the merge should be executed for. These are not necessarily selection's first
+  * and last position parents but sometimes sibling or even further blocks depending on the context.
+  *
+  * @param selection The selection the merge is executed for.
+  * @param shouldMergeOnBlocksContentLevel When `true`, merge is performed together with
+  * {@link module:engine/model/model~Model#deleteContent} to remove the inline content within the selection.
+  */
+  _getMergeSubjectElements(t, i) {
+    const s = this.editor.model, n = x(s);
+    let r, o;
+    if (t.isCollapsed || n) {
+      const l = n || t.getFirstPosition().parent, a = v(l);
+      this._direction == "backward" ? (o = l, a && !i ? (r = A.first(l, {
+        sameIndent: !0,
+        lowerIndent: !0
+      }), !r && I(l.previousSibling) && (r = l.previousSibling)) : r = l.previousSibling) : (r = l, o = l.nextSibling);
+    } else
+      r = t.getFirstPosition().parent, o = t.getLastPosition().parent;
+    return {
+      firstElement: r,
+      lastElement: o
+    };
+  }
+};
+/**
+* @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 Q = class extends D {
+  /**
+  * Creates an instance of the command.
+  *
+  * @param editor The editor instance.
+  * @param direction Whether list item should be split before or after the selected block.
+  */
+  constructor(t, i) {
+    super(t);
+    /**
+    * Whether list item should be split before or after the selected block.
+    */
+    h(this, "_direction");
+    this._direction = i;
+  }
+  /**
+  * @inheritDoc
+  */
+  refresh() {
+    this.isEnabled = this._checkEnabled();
+  }
+  /**
+  * Splits the list item at the selection.
+  *
+  * @fires execute
+  * @fires afterExecute
+  */
+  execute() {
+    this.editor.model.change((t) => {
+      const i = K(this._getStartBlock(), t);
+      this._fireAfterExecute(i);
+    });
+  }
+  /**
+  * Fires the `afterExecute` event.
+  *
+  * @param changedBlocks The changed list elements.
+  */
+  _fireAfterExecute(t) {
+    this.fire("afterExecute", w(new Set(t)));
+  }
+  /**
+  * Checks whether the command can be enabled in the current context.
+  *
+  * @returns Whether the command should be enabled.
+  */
+  _checkEnabled() {
+    const t = this.editor.model.document.selection, i = this._getStartBlock();
+    return t.isCollapsed && I(i) && !v(i);
+  }
+  /**
+  * Returns the model element that is the main focus of the command (according to the current selection and command direction).
+  */
+  _getStartBlock() {
+    const t = this.editor.model.document.selection.getFirstPosition().parent;
+    return this._direction == "before" ? t : t.nextSibling;
+  }
+};
+/**
+* @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 xt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListItemBoldIntegration";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.plugins.get("ListFormatting"), i = e.plugins.get(L);
+    !e.plugins.has("BoldEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.registerFormatAttribute("bold", "listItemBold"), i.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemBold",
+      setAttributeOnDowncast(s, n, r, o) {
+        n && (s.addClass("ck-list-marker-bold", r), q.isSafari && !(o && o.dataPipeline) && s.setStyle("--ck-content-list-marker-dummy-bold", "0", r));
+      }
+    }));
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const e = this.editor, t = e.model;
+    !e.plugins.has("BoldEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.schema.extend("$listItem", { allowAttributes: "listItemBold" }), t.schema.setAttributeProperties("listItemBold", { isFormatting: !0 }), t.schema.addAttributeCheck((i) => {
+      if (!i.last.getAttribute("listItemId")) return !1;
+    }, "listItemBold"), e.conversion.for("upcast").attributeToAttribute({
+      model: "listItemBold",
+      view: {
+        name: "li",
+        classes: "ck-list-marker-bold"
+      }
+    }));
+  }
+};
+/**
+* @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 Pt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListItemItalicIntegration";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.plugins.get("ListFormatting"), i = e.plugins.get(L);
+    !e.plugins.has("ItalicEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.registerFormatAttribute("italic", "listItemItalic"), i.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemItalic",
+      setAttributeOnDowncast(s, n, r, o) {
+        n && (s.addClass("ck-list-marker-italic", r), q.isSafari && !(o && o.dataPipeline) && s.setStyle("--ck-content-list-marker-dummy-italic", "0", r));
+      }
+    }));
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const e = this.editor, t = e.model;
+    !e.plugins.has("ItalicEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.schema.extend("$listItem", { allowAttributes: "listItemItalic" }), t.schema.setAttributeProperties("listItemItalic", { isFormatting: !0 }), t.schema.addAttributeCheck((i) => {
+      if (!i.last.getAttribute("listItemId")) return !1;
+    }, "listItemItalic"), e.conversion.for("upcast").attributeToAttribute({
+      model: "listItemItalic",
+      view: {
+        name: "li",
+        classes: "ck-list-marker-italic"
+      }
+    }));
+  }
+};
+/**
+* @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 Nt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListItemFontSizeIntegration";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.plugins.get("ListFormatting"), i = e.plugins.get(L);
+    if (!e.plugins.has("FontSizeEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting")) return;
+    const s = U(e.config.get("fontSize.options"));
+    t.registerFormatAttribute("fontSize", "listItemFontSize"), i.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemFontSize",
+      setAttributeOnDowncast(n, r, o, l) {
+        if (r) {
+          const a = s.find((u) => u.model == r);
+          a && a.view && typeof a.view != "string" ? a.view.styles ? (n.addClass("ck-list-marker-font-size", o), n.setStyle("--ck-content-list-marker-font-size", a.view.styles["font-size"], o)) : a.view.classes && (n.addClass(`ck-list-marker-font-size-${r}`, o), q.isSafari && !(l && l.dataPipeline) && n.setStyle("--ck-content-list-marker-dummy-font-size", "0", o)) : (n.addClass("ck-list-marker-font-size", o), n.setStyle("--ck-content-list-marker-font-size", r, o));
+        }
+      }
+    });
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const e = this.editor, t = e.model;
+    if (!e.plugins.has("FontSizeEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting")) return;
+    t.schema.extend("$listItem", { allowAttributes: "listItemFontSize" }), t.schema.setAttributeProperties("listItemFontSize", { isFormatting: !0 }), t.schema.addAttributeCheck((s) => {
+      if (!s.last.getAttribute("listItemId")) return !1;
+    }, "listItemFontSize"), e.conversion.for("upcast").elementToAttribute({
+      model: {
+        key: "listItemFontSize",
+        value: (s) => s.getStyle("--ck-content-list-marker-font-size")
+      },
+      view: {
+        name: "li",
+        classes: "ck-list-marker-font-size",
+        styles: { "--ck-content-list-marker-font-size": /.*/ }
+      }
+    });
+    const i = U(e.config.get("fontSize.options"));
+    for (const s of i)
+      s.model && s.view && e.conversion.for("upcast").elementToAttribute({
+        model: {
+          key: "listItemFontSize",
+          value: s.model
+        },
+        view: {
+          name: "li",
+          classes: `ck-list-marker-font-size-${s.model}`
+        }
+      });
+  }
+};
+/**
+* @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 Ot = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListItemFontColorIntegration";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.plugins.get("ListFormatting"), i = e.plugins.get(L);
+    !e.plugins.has("FontColorEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.registerFormatAttribute("fontColor", "listItemFontColor"), i.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemFontColor",
+      setAttributeOnDowncast(s, n, r) {
+        n && (s.addClass("ck-list-marker-color", r), s.setStyle("--ck-content-list-marker-color", n, r));
+      }
+    }));
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const e = this.editor, t = e.model;
+    !e.plugins.has("FontColorEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.schema.extend("$listItem", { allowAttributes: "listItemFontColor" }), t.schema.setAttributeProperties("listItemFontColor", { isFormatting: !0 }), t.schema.addAttributeCheck((i) => {
+      if (!i.last.getAttribute("listItemId")) return !1;
+    }, "listItemFontColor"), e.conversion.for("upcast").attributeToAttribute({
+      model: {
+        key: "listItemFontColor",
+        value: (i) => i.getStyle("--ck-content-list-marker-color")
+      },
+      view: {
+        name: "li",
+        classes: "ck-list-marker-color",
+        styles: { "--ck-content-list-marker-color": /.*/ }
+      }
+    }));
+  }
+};
+/**
+* @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 Mt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListItemFontFamilyIntegration";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor, t = e.plugins.get("ListFormatting"), i = e.plugins.get(L);
+    !e.plugins.has("FontFamilyEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.registerFormatAttribute("fontFamily", "listItemFontFamily"), i.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemFontFamily",
+      setAttributeOnDowncast(s, n, r) {
+        n && (s.addClass("ck-list-marker-font-family", r), s.setStyle("--ck-content-list-marker-font-family", n, r));
+      }
+    }));
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const e = this.editor, t = e.model;
+    !e.plugins.has("FontFamilyEditing") || !this.editor.config.get("list.enableListItemMarkerFormatting") || (t.schema.extend("$listItem", { allowAttributes: "listItemFontFamily" }), t.schema.setAttributeProperties("listItemFontFamily", { isFormatting: !0 }), t.schema.addAttributeCheck((i) => {
+      if (!i.last.getAttribute("listItemId")) return !1;
+    }, "listItemFontFamily"), e.conversion.for("upcast").attributeToAttribute({
+      model: {
+        key: "listItemFontFamily",
+        value: (i) => i.getStyle("--ck-content-list-marker-font-family")
+      },
+      view: {
+        name: "li",
+        classes: "ck-list-marker-font-family",
+        styles: { "--ck-content-list-marker-font-family": /.*/ }
+      }
+    }));
+  }
+};
+/**
+* @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 Vt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  constructor(t) {
+    super(t);
+    /**
+    * The list of loaded formatting.
+    */
+    h(this, "_loadedFormatting", {});
+    t.config.define("list.enableListItemMarkerFormatting", !0);
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListFormatting";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [
+      xt,
+      Pt,
+      Nt,
+      Ot,
+      Mt
+    ];
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    this.editor.config.get("list.enableListItemMarkerFormatting") && this._registerPostfixerForListItemFormatting();
+  }
+  /**
+  * Registers a postfixer that ensures that the list item formatting attribute is consistent with the formatting
+  * applied to the content of the list item.
+  */
+  _registerPostfixerForListItemFormatting() {
+    const t = this.editor.model;
+    t.document.registerPostFixer((i) => {
+      const s = t.document.differ.getChanges(), n = /* @__PURE__ */ new Set();
+      let r = !1;
+      for (const o of s) if (o.type === "attribute")
+        (o.attributeKey == "listItemId" || o.attributeKey == "listType" || this._isInlineOrSelectionFormatting(o.attributeKey) || Object.values(this._loadedFormatting).includes(o.attributeKey)) && (I(o.range.start.nodeAfter) ? n.add(o.range.start.nodeAfter) : I(o.range.start.parent) && n.add(o.range.start.parent));
+      else if (I(o.position.nodeAfter) && n.add(o.position.nodeAfter), I(o.position.nodeBefore) && n.add(o.position.nodeBefore), I(o.position.parent) && n.add(o.position.parent), o.type == "insert" && o.name != "$text") {
+        const l = i.createRangeIn(o.position.nodeAfter);
+        for (const a of l.getItems()) I(a) && n.add(a);
+      }
+      for (const o of n) {
+        const l = Dt(t, o, Object.keys(this._loadedFormatting));
+        for (const [a, u] of Object.entries(l)) {
+          const c = this._loadedFormatting[a];
+          (u && zt(i, o, c, u) || !u && Rt(i, o, c)) && (r = !0);
+        }
+      }
+      return r;
+    });
+  }
+  /**
+  * Registers an integration between a default attribute (e.g., `fontFamily`) and a new attribute
+  * intended specifically for list item elements (e.g., `listItemFontFamily`).
+  *
+  * These attributes are later used by the postfixer logic to determine whether to add the new attribute
+  * to the list item element, based on whether there is a consistent default formatting attribute
+  * applied within its content.
+  */
+  registerFormatAttribute(t, i) {
+    this._loadedFormatting[t] = i;
+  }
+  /**
+  * Returns true if the given model attribute name is a supported inline formatting attribute.
+  */
+  _isInlineOrSelectionFormatting(t) {
+    return t.replace(/^selection:/, "") in this._loadedFormatting;
+  }
+};
+function Dt(e, t, i) {
+  return v(t) ? X(e, t, i) : X(e, E(t)[0], i);
+}
+function X(e, t, i) {
+  if (!$t(t) || e.schema.isLimit(t)) return Object.fromEntries(i.map((o) => [o]));
+  if (t.isEmpty) return Object.fromEntries(i.map((o) => [o, t.getAttribute(`selection:${o}`)]));
+  const s = new Set(i), n = {}, r = e.createRangeIn(t).getWalker({ ignoreElementEnd: !0 });
+  for (const { item: o } of r) {
+    for (const l of s) if (e.schema.checkAttribute(o, l)) {
+      const a = o.getAttribute(l);
+      a === void 0 ? (s.delete(l), n[l] = void 0) : n[l] === void 0 ? n[l] = a : n[l] !== a && (s.delete(l), n[l] = void 0);
+    } else l in n || (n[l] = void 0);
+    if (!s.size) break;
+    e.schema.isLimit(o) && r.jumpTo(e.createPositionAfter(o));
+  }
+  return n;
+}
+function zt(e, t, i, s) {
+  const n = E(t);
+  let r = !1;
+  for (const o of n) (!o.hasAttribute(i) || o.getAttribute(i) !== s) && (e.setAttribute(i, s, o), r = !0);
+  return r;
+}
+function Rt(e, t, i) {
+  const s = E(t);
+  let n = !1;
+  for (const r of s) r.hasAttribute(i) && (e.removeAttribute(i, r), n = !0);
+  return n;
+}
+function $t(e) {
+  return [
+    "numbered",
+    "bulleted",
+    "customNumbered",
+    "customBulleted"
+  ].includes(e.getAttribute("listType"));
+}
+/**
+* @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 jt = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListUtils";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * Expands the given list of selected blocks to include all the items of the lists they're in.
+  *
+  * @param blocks The list of selected blocks.
+  */
+  expandListBlocksToCompleteList(e) {
+    return wt(e);
+  }
+  /**
+  * Check if the given block is the first in the list item.
+  *
+  * @param listBlock The list block element.
+  */
+  isFirstBlockOfListItem(e) {
+    return v(e);
+  }
+  /**
+  * Returns true if the given model node is a list item block.
+  *
+  * @param node A model node.
+  */
+  isListItemBlock(e) {
+    return I(e);
+  }
+  /**
+  * Expands the given list of selected blocks to include the leading and tailing blocks of partially selected list items.
+  *
+  * @param blocks The list of selected blocks.
+  * @param options.withNested Whether should include nested list items.
+  */
+  expandListBlocksToCompleteItems(e, t = {}) {
+    return N(e, t);
+  }
+  /**
+  * Returns true if listType is of type `numbered` or `customNumbered`.
+  */
+  isNumberedListType(e) {
+    return Et(e);
+  }
+  /**
+  * Returns true if the given list item is the first item in the list.
+  */
+  isFirstListItemInList(e) {
+    return Ct(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
+*/
+function Wt(e) {
+  return e.is("element", "ol") || e.is("element", "ul");
+}
+function W(e) {
+  return e.is("element", "li");
+}
+function qt(e) {
+  let t = 0, i = e.parent;
+  for (; i; ) {
+    if (W(i)) t++;
+    else {
+      const s = i.previousSibling;
+      s && W(s) && t++;
+    }
+    i = i.parent;
+  }
+  return t;
+}
+function Z(e, t, i, s = at(i, t)) {
+  return e.createAttributeElement(lt(i), null, {
+    priority: 2 * t / 100 - 100,
+    id: s
+  });
+}
+function tt(e, t, i) {
+  return e.createAttributeElement("li", null, {
+    priority: (2 * t + 1) / 100 - 100,
+    id: i
+  });
+}
+function lt(e) {
+  return e == "numbered" || e == "customNumbered" ? "ol" : "ul";
+}
+function at(e, t) {
+  return `list-${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
+*/
+function y(e, t, i) {
+  const s = e.nodeBefore;
+  if (I(s)) {
+    let n = s;
+    for (const { node: r } of new P(n, "backward"))
+      if (n = r, i.has(n) || (i.add(n), t.has(s))) return;
+    t.add(n);
+  } else {
+    const n = e.nodeAfter;
+    I(n) && t.add(n);
+  }
+}
+function Kt(e, t) {
+  let i = 0, s = -1, n = null, r = !1;
+  for (const { node: o } of e) {
+    const l = o.getAttribute("listIndent");
+    if (l > i) {
+      let a;
+      n === null ? (n = l - i, a = i) : (n > l && (n = l), a = l - n), a > s + 1 && (a = s + 1), t.setAttribute("listIndent", a, o), r = !0, s = a;
+    } else
+      n = null, i = l + 1, s = l;
+  }
+  return r;
+}
+function Ut(e, t, i) {
+  const s = /* @__PURE__ */ new Set();
+  let n = !1;
+  for (const { node: r } of e) {
+    if (s.has(r)) continue;
+    let o = r.getAttribute("listType"), l = r.getAttribute("listItemId");
+    if (t.has(l) && (l = F.next()), t.add(l), r.is("element", "listItem")) {
+      r.getAttribute("listItemId") != l && (i.setAttribute("listItemId", l, r), n = !0);
+      continue;
+    }
+    for (const a of S(r, { direction: "forward" }))
+      s.add(a), a.getAttribute("listType") != o && (l = F.next(), o = a.getAttribute("listType")), a.getAttribute("listItemId") != l && (i.setAttribute("listItemId", l, a), n = !0);
+  }
+  return 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
+*/
+function Ht() {
+  return (e, t, i) => {
+    const s = t.viewItem;
+    if (s.getStyle("list-style-type") !== "none" || !Yt(s) || !i.consumable.consume(s, { name: !0 })) return;
+    const { modelRange: n, modelCursor: r } = i.convertChildren(s, t.modelCursor);
+    t.modelRange = n, t.modelCursor = r;
+  };
+}
+function Yt(e) {
+  let t = !1;
+  for (const i of e.getChildren()) {
+    if (i.is("element", "ul") || i.is("element", "ol")) {
+      t = !0;
+      continue;
+    }
+    return !1;
+  }
+  return t;
+}
+function Gt() {
+  return (e, t, i) => {
+    const { writer: s, schema: n } = i;
+    if (!t.modelRange) return;
+    const r = Array.from(t.modelRange.getItems({ shallow: !0 })).filter((d) => n.checkAttribute(d, "listItemId"));
+    if (!r.length || r.every((d) => d.hasAttribute("listItemId"))) return;
+    const o = t.viewItem.getAttribute("data-list-item-id") || F.next();
+    i.consumable.consume(t.viewItem, { attributes: "data-list-item-id" });
+    const l = qt(t.viewItem);
+    let a = t.viewItem.parent && t.viewItem.parent.is("element", "ol") ? "numbered" : "bulleted";
+    const u = r[0].getAttribute("listType");
+    u && (a = u);
+    const c = {
+      listItemId: o,
+      listIndent: l,
+      listType: a
+    };
+    for (const d of r) d.hasAttribute("listItemId") || s.setAttributes(c, d);
+    r.length > 1 && r[1].getAttribute("listItemId") != c.listItemId && i.keepEmptyElement(r[0]);
+  };
+}
+function Jt(e, t, i, s) {
+  return () => {
+    const c = e.document.differ.getChanges(), d = [], m = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set();
+    for (const f of c) if (f.type == "insert" && f.name != "$text")
+      y(f.position, m, p), f.attributes.has("listItemId") ? g.add(f.position.nodeAfter) : y(f.position.getShiftedBy(f.length), m, p);
+    else if (f.type == "remove" && f.attributes.has("listItemId")) y(f.position, m, p);
+    else if (f.type == "attribute") {
+      const b = f.range.start.nodeAfter;
+      i.includes(f.attributeKey) ? (y(f.range.start, m, p), f.attributeNewValue === null ? (y(f.range.start.getShiftedBy(1), m, p), l(b) && d.push(b)) : g.add(b)) : I(b) && l(b) && d.push(b);
+    }
+    for (const f of m.values()) d.push(...n(f, g));
+    for (const f of new Set(d)) t.reconvertItem(f);
+  };
+  function n(c, d) {
+    const m = [], g = /* @__PURE__ */ new Set(), p = [];
+    for (const { node: f, previous: b } of new P(c)) {
+      if (g.has(f)) continue;
+      const k = f.getAttribute("listIndent");
+      b && k < b.getAttribute("listIndent") && (p.length = k + 1), p[k] = {
+        modelAttributes: r(f),
+        modelElement: f
+      }, o(f, k, p);
+      const O = S(f, { direction: "forward" });
+      for (const C of O)
+        g.add(C), (l(C, O) || u(C, p, d)) && m.push(C);
+    }
+    return m;
+  }
+  function r(c) {
+    return Object.fromEntries(Array.from(c.getAttributes()).filter(([d]) => i.includes(d)));
+  }
+  function o(c, d, m) {
+    for (let g = d - 1; g >= 0 && !m[g]; g--) {
+      const p = ut(c, g);
+      let f = null;
+      if (!p) {
+        for (let k = g - 1; k >= 0; k--) if (m[k]) {
+          f = m[k].modelElement;
+          break;
+        }
+      }
+      const b = p || f || c;
+      m[g] = {
+        modelAttributes: {
+          ...r(b),
+          listItemId: `list-item-skip-${g}`,
+          listIndent: g
+        },
+        modelElement: b
+      };
+    }
+  }
+  function l(c, d) {
+    const m = t.mapper.toViewElement(c);
+    if (!m) return !1;
+    if (a(m) || s.fire("checkElement", {
+      modelElement: c,
+      viewElement: m
+    })) return !0;
+    if (!c.is("element", "paragraph") && !c.is("element", "listItem")) return !1;
+    const g = mt(c, i, d);
+    return g && m.is("element", "p") ? !0 : !!(!g && m.is("element", "span"));
+  }
+  function a(c) {
+    for (c = c.parent; c.is("attributeElement") && [
+      "ol",
+      "ul",
+      "li"
+    ].includes(c.name); ) c = c.parent;
+    return !!(c.getCustomProperty("$structureSlotParent") && !t.mapper.toModelElement(c));
+  }
+  function u(c, d, m) {
+    if (m.has(c)) return !1;
+    const g = t.mapper.toViewElement(c);
+    let p = d.length - 1;
+    for (let f = g.parent; !f.is("editableElement"); f = f.parent) {
+      const b = W(f), k = Wt(f);
+      if (!(!k && !b)) {
+        if (d[p]) {
+          const O = `checkAttributes:${b ? "item" : "list"}`;
+          if (s.fire(O, {
+            viewElement: f,
+            modelAttributes: d[p].modelAttributes,
+            modelReferenceElement: d[p].modelElement
+          })) break;
+        }
+        if (k && (p--, p < 0))
+          return !1;
+      }
+    }
+    return !0;
+  }
+}
+function et(e, t, i, { dataPipeline: s, enableSkipLevelLists: n }) {
+  const r = se(e, t);
+  return (o, l, a) => {
+    const { writer: u, mapper: c, consumable: d } = a, m = l.item;
+    if (!e.includes(l.attributeKey) || !r(m, d)) return;
+    const g = {
+      ...a.options,
+      dataPipeline: s,
+      enableSkipLevelLists: n
+    }, p = Xt(m, c, i, u);
+    ct(p, u, c), ee(p, u), ie(m, te(m, p, t, u, g), t, u, g);
+  };
+}
+function Qt(e) {
+  return (t, i, s) => {
+    const { writer: n, mapper: r } = s, o = t.name.split(":")[1];
+    if (!e.checkAttribute(o, "listItemId")) return;
+    const l = r.toViewPosition(i.position), a = i.position.getShiftedBy(i.length), u = r.toViewPosition(a, { isPhantom: !0 }), c = n.createRange(l, u).getTrimmed().end.nodeBefore;
+    /* istanbul ignore next -- @preserve */
+    c && ct(c, n, r);
+  };
+}
+function it(e, { dataPipeline: t } = {}) {
+  return (i, { writer: s }) => {
+    if (!mt(i, e)) return null;
+    if (!t) return s.createContainerElement("span", { class: "ck-list-bogus-paragraph" });
+    const n = s.createContainerElement("p");
+    return s.setCustomProperty("dataPipeline:transparentRendering", !0, n), n;
+  };
+}
+function Xt(e, t, i, s) {
+  const n = i.createRangeOn(e), r = t.toViewRange(n).getTrimmed().getWalker();
+  for (const { item: o } of r) if (o.is("element") && o.getCustomProperty("listItemMarker")) r.jumpTo(s.createPositionAfter(o));
+  else if (o.is("element") && !o.getCustomProperty("listItemWrapper")) return o;
+}
+function Zt(e, t) {
+  return (i, s) => {
+    if (s.modelPosition.offset > 0) return;
+    const n = s.modelPosition.parent;
+    if (!I(n) || !e.some((u) => u.scope == "itemMarker" && u.canInjectMarkerIntoElement && u.canInjectMarkerIntoElement(n))) return;
+    const r = s.mapper.toViewElement(n), o = t.createRangeIn(r), l = o.getWalker();
+    let a = o.start;
+    for (const { item: u } of l) {
+      if (u.is("element") && s.mapper.toModelElement(u) || u.is("$textProxy")) break;
+      u.is("element") && u.getCustomProperty("listItemMarker") && (a = t.createPositionAfter(u), l.skip(({ previousPosition: c }) => !c.isEqual(a)));
+    }
+    s.viewPosition = a;
+  };
+}
+function ct(e, t, i) {
+  for (; e.parent.is("attributeElement") && e.parent.getCustomProperty("listItemWrapper"); ) t.unwrap(t.createRangeOn(e), e.parent);
+  const s = [];
+  n(t.createPositionBefore(e).getWalker({ direction: "backward" })), n(t.createRangeIn(e).getWalker());
+  for (const r of s) t.remove(r);
+  function n(r) {
+    for (const { item: o } of r) {
+      if (o.is("element") && i.toModelElement(o)) break;
+      o.is("element") && o.getCustomProperty("listItemMarker") && s.push(o);
+    }
+  }
+}
+function te(e, t, i, s, { dataPipeline: n }) {
+  let r = s.createRangeOn(t);
+  if (!v(e)) return r;
+  for (const o of i) {
+    if (o.scope != "itemMarker") continue;
+    const l = o.createElement(s, e, { dataPipeline: n });
+    if (!l || (s.setCustomProperty("listItemMarker", !0, l), o.canInjectMarkerIntoElement && o.canInjectMarkerIntoElement(e) ? s.insert(s.createPositionAt(t, 0), l) : (s.insert(r.start, l), r = s.createRange(s.createPositionBefore(l), s.createPositionAfter(t))), !o.createWrapperElement || !o.canWrapElement)) continue;
+    const a = o.createWrapperElement(s, e, { dataPipeline: n });
+    s.setCustomProperty("listItemWrapper", !0, a), o.canWrapElement(e) ? r = s.wrap(r, a) : (r = s.wrap(s.createRangeOn(l), a), r = s.createRange(r.start, s.createPositionAfter(t)));
+  }
+  return r;
+}
+function ee(e, t) {
+  let i = e.parent;
+  for (; i.is("attributeElement") && [
+    "ul",
+    "ol",
+    "li"
+  ].includes(i.name); ) {
+    const s = i.parent;
+    t.unwrap(t.createRangeOn(e), i), i = s;
+  }
+}
+function ie(e, t, i, s, n) {
+  if (!e.hasAttribute("listIndent")) return;
+  const r = e.getAttribute("listIndent"), o = n.enableSkipLevelLists;
+  let l = e;
+  for (let a = r; a >= 0; a--) {
+    const u = l.getAttribute("listIndent") !== a;
+    if (u) {
+      const c = ut(e, a) || l, d = c.getAttribute("listType"), m = tt(s, a, `list-item-skip-${a}`), g = Z(s, a, d);
+      s.setStyle("list-style-type", "none", m);
+      for (const p of i) p.scope == "list" && c.hasAttribute(p.attributeName) && p.setAttributeOnDowncast(s, c.getAttribute(p.attributeName), g, n, c);
+      t = s.wrap(t, m), t = s.wrap(t, g);
+    } else {
+      const c = tt(s, a, l.getAttribute("listItemId")), d = Z(s, a, l.getAttribute("listType"));
+      for (const m of i) (m.scope == "list" || m.scope == "item") && l.hasAttribute(m.attributeName) && m.setAttributeOnDowncast(s, l.getAttribute(m.attributeName), m.scope == "list" ? d : c, n, l);
+      t = s.wrap(t, c), t = s.wrap(t, d);
+    }
+    if (a == 0) break;
+    if (!u) {
+      const c = A.first(l, { lowerIndent: !0 });
+      if (c) l = c;
+      else if (!o) break;
+    }
+  }
+}
+function ut(e, t) {
+  let i = e.nextSibling;
+  for (; i && I(i); ) {
+    const s = i.getAttribute("listIndent");
+    if (s < t) return null;
+    if (s === t) return i;
+    i = i.nextSibling;
+  }
+  return null;
+}
+function se(e, t) {
+  const i = t.filter((s) => s.consume === !1).map((s) => s.attributeName);
+  return (s, n) => {
+    const r = [];
+    for (const o of e) s.hasAttribute(o) && !i.includes(o) && r.push(`attribute:${o}`);
+    return r.every((o) => n.test(s, o) !== !1) ? (r.forEach((o) => n.consume(s, o)), !0) : !1;
+  };
+}
+function mt(e, t, i = E(e)) {
+  if (!I(e)) return !1;
+  for (const s of e.getAttributeKeys())
+    if (!(s.startsWith("selection:") || s == "htmlEmptyBlock") && !t.includes(s))
+      return !1;
+  return i.length < 2;
+}
+/**
+* @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 = [
+  "listType",
+  "listIndent",
+  "listItemId"
+];
+var L = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  constructor(t) {
+    super(t);
+    /**
+    * The list of registered downcast strategies.
+    */
+    h(this, "_downcastStrategies", []);
+    t.config.define("list.multiBlock", !0);
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListEditing";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [
+      pt,
+      gt,
+      jt,
+      kt,
+      Vt
+    ];
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const t = this.editor, i = t.model, s = t.config.get("list.multiBlock");
+    if (t.plugins.has("LegacyListEditing"))
+      throw new It("list-feature-conflict", this, { conflictPlugin: "LegacyListEditing" });
+    i.schema.register("$listItem", { allowAttributes: V }), s ? (i.schema.extend("$container", { allowAttributesOf: "$listItem" }), i.schema.extend("$block", { allowAttributesOf: "$listItem" }), i.schema.extend("$blockObject", { allowAttributesOf: "$listItem" })) : i.schema.register("listItem", {
+      inheritAllFrom: "$block",
+      allowAttributesOf: "$listItem"
+    });
+    for (const n of V) i.schema.setAttributeProperties(n, { copyOnReplace: !0 });
+    t.commands.add("numberedList", new M(t, "numbered")), t.commands.add("bulletedList", new M(t, "bulleted")), t.commands.add("customNumberedList", new M(t, "customNumbered", { multiLevel: !0 })), t.commands.add("customBulletedList", new M(t, "customBulleted", { multiLevel: !0 })), t.commands.add("indentList", new Y(t, "forward")), t.commands.add("outdentList", new Y(t, "backward")), t.commands.add("splitListItemBefore", new Q(t, "before")), t.commands.add("splitListItemAfter", new Q(t, "after")), s && (t.commands.add("mergeListItemBackward", new J(t, "backward")), t.commands.add("mergeListItemForward", new J(t, "forward"))), this._setupDeleteIntegration(), this._setupEnterIntegration(), this._setupTabIntegration(), this._setupClipboardIntegration(), this._setupAccessibilityIntegration(), this._setupListItemIdConversionStrategy();
+  }
+  /**
+  * @inheritDoc
+  */
+  afterInit() {
+    const t = this.editor.commands, i = t.get("indent"), s = t.get("outdent");
+    i && i.registerChildCommand(t.get("indentList"), { priority: "high" }), s && s.registerChildCommand(t.get("outdentList"), { priority: "lowest" }), this._setupModelPostFixing(), this._setupConversion();
+  }
+  /**
+  * Registers a downcast strategy.
+  *
+  * **Note**: Strategies must be registered in the `Plugin#init()` phase so that it can be applied
+  * in the `ListEditing#afterInit()`.
+  *
+  * @param strategy The downcast strategy to register.
+  */
+  registerDowncastStrategy(t) {
+    this._downcastStrategies.push(t);
+  }
+  /**
+  * Returns list of model attribute names that should affect downcast conversion.
+  */
+  getListAttributeNames() {
+    return [...V, ...this._downcastStrategies.map((t) => t.attributeName)];
+  }
+  /**
+  * Attaches the listener to the {@link module:engine/view/document~ViewDocument#event:delete} event and handles backspace/delete
+  * keys in and around document lists.
+  */
+  _setupDeleteIntegration() {
+    const t = this.editor, i = t.commands.get("mergeListItemBackward"), s = t.commands.get("mergeListItemForward");
+    this.listenTo(t.editing.view.document, "delete", (n, r) => {
+      const o = t.model.document.selection;
+      x(t.model) || t.model.change(() => {
+        const l = o.getFirstPosition();
+        if (o.isCollapsed && r.direction == "backward") {
+          if (!l.isAtStart) return;
+          const a = l.parent;
+          if (!I(a)) return;
+          const u = A.first(a, {
+            sameAttributes: "listType",
+            sameIndent: !0
+          }), c = a.getAttribute("listIndent") === 0 || !I(a.previousSibling);
+          if (!u && c)
+            H(a) || t.execute("splitListItemAfter"), t.execute("outdentList");
+          else {
+            if (!i || !i.isEnabled) return;
+            i.execute({ shouldMergeOnBlocksContentLevel: st(t.model, "backward") });
+          }
+          r.preventDefault(), n.stop();
+        } else {
+          if (o.isCollapsed && !o.getLastPosition().isAtEnd || !s || !s.isEnabled) return;
+          s.execute({ shouldMergeOnBlocksContentLevel: st(t.model, "forward") }), r.preventDefault(), n.stop();
+        }
+      });
+    }, { context: "li" });
+  }
+  /**
+  * Attaches a listener to the {@link module:engine/view/document~ViewDocument#event:enter} event and handles enter key press
+  * in document lists.
+  */
+  _setupEnterIntegration() {
+    const t = this.editor, i = t.model, s = t.commands, n = s.get("enter");
+    this.listenTo(t.editing.view.document, "enter", (r, o) => {
+      const l = i.document, a = l.selection.getFirstPosition().parent;
+      if (l.selection.isCollapsed && I(a) && a.isEmpty && !o.isSoft) {
+        const u = v(a), c = H(a);
+        u && c ? (t.execute("outdentList"), o.preventDefault(), r.stop()) : u && !c ? (t.execute("splitListItemAfter"), o.preventDefault(), r.stop()) : c && (t.execute("splitListItemBefore"), o.preventDefault(), r.stop());
+      }
+    }, { context: "li" }), this.listenTo(n, "afterExecute", () => {
+      const r = s.get("splitListItemBefore");
+      if (r.refresh(), !r.isEnabled) return;
+      const o = t.model.document.selection.getLastPosition().parent;
+      E(o).length === 2 && r.execute();
+    });
+  }
+  /**
+  * Attaches a listener to the {@link module:engine/view/document~ViewDocument#event:tab} event and handles tab key and tab+shift keys
+  * presses in document lists.
+  */
+  _setupTabIntegration() {
+    const t = this.editor;
+    this.listenTo(t.editing.view.document, "tab", (i, s) => {
+      const n = s.shiftKey ? "outdentList" : "indentList";
+      this.editor.commands.get(n).isEnabled && (t.execute(n), s.stopPropagation(), s.preventDefault(), i.stop());
+    }, { context: "li" });
+  }
+  /**
+  * Registers the conversion helpers for the document-list feature.
+  */
+  _setupConversion() {
+    const t = this.editor, i = t.model, s = this.getListAttributeNames(), n = t.config.get("list.multiBlock"), r = n ? "paragraph" : "listItem", o = !!t.config.get("list.enableSkipLevelLists");
+    t.conversion.for("upcast").elementToElement({
+      view: "li",
+      model: (a, { writer: u }) => u.createElement(r, { listType: "" })
+    }).elementToElement({
+      view: "p",
+      model: (a, { writer: u }) => a.parent && a.parent.is("element", "li") ? u.createElement(r, { listType: "" }) : null,
+      converterPriority: "high"
+    }).add((a) => {
+      a.on("element:p", (u, c, d) => {
+        const m = c.viewItem;
+        if (!m.parent || !m.parent.is("element", "li") || m.isEmpty || !m.getAttributeKeys().next().done) return;
+        for (const f of m.parent.getChildren())
+          if (f !== m && !(f.is("element", "ol") || f.is("element", "ul")))
+            return;
+        d.consumable.consume(m, { name: !0 });
+        const { modelRange: g, modelCursor: p } = d.convertChildren(m, c.modelCursor);
+        c.modelRange = g, c.modelCursor = p;
+      }, { priority: "highest" }), o && a.on("element:li", Ht(), { priority: "high" }), a.on("element:li", Gt());
+    }), n || t.conversion.for("downcast").elementToElement({
+      model: "listItem",
+      view: "p"
+    }), t.conversion.for("editingDowncast").elementToElement({
+      model: r,
+      view: it(s),
+      converterPriority: "high"
+    }).add((a) => {
+      a.on("attribute", et(s, this._downcastStrategies, i, { enableSkipLevelLists: o })), a.on("remove", Qt(i.schema));
+    }), t.conversion.for("dataDowncast").elementToElement({
+      model: r,
+      view: it(s, { dataPipeline: !0 }),
+      converterPriority: "high"
+    }).add((a) => {
+      a.on("attribute", et(s, this._downcastStrategies, i, {
+        dataPipeline: !0,
+        enableSkipLevelLists: o
+      }));
+    });
+    const l = Zt(this._downcastStrategies, t.editing.view);
+    t.editing.mapper.on("modelToViewPosition", l), t.data.mapper.on("modelToViewPosition", l), this.listenTo(i.document, "change:data", Jt(i, t.editing, s, this), { priority: "high" }), this.on("checkAttributes:item", (a, { viewElement: u, modelAttributes: c }) => {
+      u.id != c.listItemId && (a.return = !0, a.stop());
+    }), this.on("checkAttributes:list", (a, { viewElement: u, modelAttributes: c }) => {
+      (u.name != lt(c.listType) || u.id != at(c.listType, c.listIndent)) && (a.return = !0, a.stop());
+    });
+  }
+  /**
+  * Registers model post-fixers.
+  */
+  _setupModelPostFixing() {
+    const t = this.editor.model, i = this.getListAttributeNames();
+    t.document.registerPostFixer((s) => ne(t, s, i, this)), this.editor.config.get("list.enableSkipLevelLists") || this.on("postFixer", (s, { listNodes: n, writer: r }) => {
+      s.return = Kt(n, r) || s.return;
+    }, { priority: "high" }), this.on("postFixer", (s, { listNodes: n, writer: r, seenIds: o }) => {
+      s.return = Ut(n, o, r) || s.return;
+    }, { priority: "high" });
+  }
+  /**
+  * Integrates the feature with the clipboard via {@link module:engine/model/model~Model#insertContent} and
+  * {@link module:engine/model/model~Model#getSelectedContent}.
+  */
+  _setupClipboardIntegration() {
+    const t = this.editor.model, i = this.editor.plugins.get("ClipboardPipeline");
+    this.listenTo(t, "insertContent", re(t), { priority: "high" }), this.listenTo(i, "outputTransformation", (s, n) => {
+      t.change((r) => {
+        const o = Array.from(n.content.getChildren()), l = o[o.length - 1];
+        if (o.length > 1 && l.is("element") && l.isEmpty && o.slice(0, -1).every(I) && r.remove(l), n.method == "copy" || n.method == "cut") {
+          const a = Array.from(n.content.getChildren());
+          T(a) && z(a, r, this.getListAttributeNames());
+        }
+      });
+    });
+  }
+  /**
+  * Informs editor accessibility features about keystrokes brought by the plugin.
+  */
+  _setupAccessibilityIntegration() {
+    const t = this.editor, i = t.t;
+    t.accessibility.addKeystrokeInfoGroup({
+      id: "list",
+      label: i("Keystrokes that can be used in a list"),
+      keystrokes: [{
+        label: i("Increase list item indent"),
+        keystroke: "Tab"
+      }, {
+        label: i("Decrease list item indent"),
+        keystroke: "Shift+Tab"
+      }]
+    });
+  }
+  /**
+  * Convert `listItemId` attribute to `data-list-item-id` attribute on the view element in both downcast pipelines.
+  */
+  _setupListItemIdConversionStrategy() {
+    this.registerDowncastStrategy({
+      scope: "item",
+      attributeName: "listItemId",
+      setAttributeOnDowncast(t, i, s, n) {
+        n && (n.skipListItemIds || n.isClipboardPipeline) || t.setAttribute("data-list-item-id", i, s);
+      }
+    });
+  }
+};
+function ne(e, t, i, s) {
+  const n = e.document.differ.getChanges(), r = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), l = s.editor.config.get("list.multiBlock");
+  let a = !1;
+  for (const c of n) {
+    if (c.type == "insert" && c.name != "$text") {
+      const d = c.position.nodeAfter;
+      if (!e.schema.checkAttribute(d, "listItemId"))
+        for (const m of Array.from(d.getAttributeKeys())) i.includes(m) && (t.removeAttribute(m, d), a = !0);
+      y(c.position, o, r), c.attributes.has("listItemId") || y(c.position.getShiftedBy(c.length), o, r);
+      for (const { item: m, previousPosition: g } of e.createRangeIn(d)) I(m) && y(g, o, r);
+    } else c.type == "remove" ? y(c.position, o, r) : c.type == "attribute" && i.includes(c.attributeKey) && (y(c.range.start, o, r), c.attributeNewValue === null && y(c.range.start.getShiftedBy(1), o, r));
+    if (!l && c.type == "attribute" && V.includes(c.attributeKey)) {
+      const d = c.range.start.nodeAfter;
+      c.attributeNewValue === null && d && d.is("element", "listItem") ? (t.rename(d, "paragraph"), a = !0) : c.attributeOldValue === null && d && d.is("element") && d.name != "listItem" && (t.rename(d, "listItem"), a = !0);
+    }
+  }
+  const u = /* @__PURE__ */ new Set();
+  for (const c of o.values()) a = s.fire("postFixer", {
+    listNodes: new St(c),
+    listHead: c,
+    writer: t,
+    seenIds: u
+  }) || a;
+  return a;
+}
+function re(e) {
+  return (t, [i, s]) => {
+    const n = (i.is("documentFragment") ? Array.from(i.getChildren()) : [i]).filter((l) => !e.schema.isInline(l));
+    if (!n.length) return;
+    const r = (s ? e.createSelection(s) : e.document.selection).getFirstPosition();
+    let o;
+    if (I(r.parent)) o = r.parent;
+    else if (I(r.nodeBefore) && I(r.nodeAfter)) o = r.nodeBefore;
+    else return;
+    e.change((l) => {
+      const a = o.getAttribute("listType"), u = o.getAttribute("listIndent"), c = n[0].getAttribute("listIndent") || 0, d = Math.max(u - c, 0);
+      for (const m of n) {
+        const g = I(m);
+        o.is("element", "listItem") && m.is("element", "paragraph") && l.rename(m, "listItem"), l.setAttributes({
+          listIndent: (g ? m.getAttribute("listIndent") : 0) + d,
+          listItemId: g ? m.getAttribute("listItemId") : F.next(),
+          listType: a
+        }, m);
+      }
+    });
+  };
+}
+function st(e, t) {
+  const i = e.document.selection;
+  if (!i.isCollapsed) return !x(e);
+  if (t === "forward") return !0;
+  const s = i.getFirstPosition().parent, n = s.previousSibling;
+  return e.schema.isObject(n) ? !1 : n.isEmpty ? !0 : T([s, 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
+*/
+function nt(e, t, i, s) {
+  e.ui.componentFactory.add(t, () => {
+    const n = rt(At, e, t, i, s);
+    return n.set({
+      tooltip: !0,
+      isToggleable: !0
+    }), n;
+  }), e.ui.componentFactory.add(`menuBar:${t}`, () => {
+    const n = rt(yt, e, t, i, s);
+    return n.set({
+      role: "menuitemcheckbox",
+      isToggleable: !0
+    }), n;
+  });
+}
+function rt(e, t, i, s, n) {
+  const r = t.commands.get(i), o = new e(t.locale);
+  return o.set({
+    label: s,
+    icon: n
+  }), o.bind("isOn", "isEnabled").to(r, "value", "isEnabled"), o.on("execute", () => {
+    t.execute(i), t.editing.view.focus();
+  }), o;
+}
+/**
+* @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 oe = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "ListUI";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    const e = this.editor.t;
+    this.editor.ui.componentFactory.has("numberedList") || nt(this.editor, "numberedList", e("Numbered List"), Lt), this.editor.ui.componentFactory.has("bulletedList") || nt(this.editor, "bulletedList", e("Bulleted List"), _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 be = class extends _ {
+  /**
+  * @inheritDoc
+  */
+  static get requires() {
+    return [L, oe];
+  }
+  /**
+  * @inheritDoc
+  */
+  static get pluginName() {
+    return "List";
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isOfficialPlugin() {
+    return !0;
+  }
+};
+const le = [
+  {
+    listStyle: "disc",
+    typeAttribute: "disc",
+    listType: "bulleted"
+  },
+  {
+    listStyle: "circle",
+    typeAttribute: "circle",
+    listType: "bulleted"
+  },
+  {
+    listStyle: "square",
+    typeAttribute: "square",
+    listType: "bulleted"
+  },
+  {
+    listStyle: "decimal",
+    typeAttribute: "1",
+    listType: "numbered"
+  },
+  {
+    listStyle: "decimal-leading-zero",
+    typeAttribute: null,
+    listType: "numbered"
+  },
+  {
+    listStyle: "lower-roman",
+    typeAttribute: "i",
+    listType: "numbered"
+  },
+  {
+    listStyle: "upper-roman",
+    typeAttribute: "I",
+    listType: "numbered"
+  },
+  {
+    listStyle: "lower-alpha",
+    typeAttribute: "a",
+    listType: "numbered"
+  },
+  {
+    listStyle: "upper-alpha",
+    typeAttribute: "A",
+    listType: "numbered"
+  },
+  {
+    listStyle: "lower-latin",
+    typeAttribute: "a",
+    listType: "numbered"
+  },
+  {
+    listStyle: "upper-latin",
+    typeAttribute: "A",
+    listType: "numbered"
+  },
+  {
+    listStyle: "arabic-indic",
+    typeAttribute: null,
+    listType: "numbered"
+  }
+];
+for (const { listStyle: e, typeAttribute: t, listType: i } of le)
+  ;
+export {
+  be as List,
+  M as ListCommand,
+  L as ListEditing,
+  Vt as ListFormatting,
+  Y as ListIndentCommand,
+  xt as ListItemBoldIntegration,
+  Ot as ListItemFontColorIntegration,
+  Mt as ListItemFontFamilyIntegration,
+  Nt as ListItemFontSizeIntegration,
+  Pt as ListItemItalicIntegration,
+  J as ListMergeCommand,
+  Q as ListSplitCommand,
+  oe as ListUI,
+  jt as ListUtils,
+  St as _ListBlocksIterable,
+  F as _ListItemUid,
+  A as _ListWalker,
+  P as _SiblingListBlocksIterator,
+  R as _canBecomeSimpleListItem,
+  Z as _createListElement,
+  tt as _createListItemElement,
+  nt as _createListUIComponents,
+  Zt as _createModelToViewListPositionMapper,
+  N as _expandListBlocksToCompleteItems,
+  wt as _expandListBlocksToCompleteList,
+  y as _findAndAddListHeadToMap,
+  Xt as _findMappedListItemViewElement,
+  Kt as _fixListIndents,
+  Ut as _fixListItemIds,
+  E as _getAllListItemBlocks,
+  qt as _getListIndent,
+  S as _getListItemBlocks,
+  ot as _getListItems,
+  vt as _getNestedListBlocks,
+  x as _getSelectedBlockObject,
+  at as _getViewElementIdForListType,
+  lt as _getViewElementNameForListType,
+  j as _indentListBlocks,
+  v as _isFirstBlockOfListItem,
+  H as _isLastBlockOfListItem,
+  I as _isListItemBlock,
+  W as _isListItemView,
+  Wt as _isListView,
+  Et as _isNumberedListType,
+  T as _isSingleListItem,
+  it as _listItemBogusParagraphCreator,
+  et as _listItemDowncastConverter,
+  Qt as _listItemDowncastRemoveConverter,
+  Gt as _listItemUpcastConverter,
+  $ as _mergeListItemBefore,
+  Bt as _outdentFollowingListItems,
+  Ft as _outdentListBlocksWithMerge,
+  Jt as _reconvertListItemsOnDataChange,
+  z as _removeListAttributes,
+  w as _sortListBlocks,
+  K as _splitListItemBefore
+};
+//# sourceMappingURL=index.js.map